Пример обработки данных

Benchmark name is “PublisherFixture/ROS_BM_Publish_method” by var=subs_count where size=1024 buffer=1
Benchmark name is “PublisherFixture/ROS_BM_Publish_method” by var=subs_count where size=1024 buffer=10
Benchmark name is “PublisherFixture/ROS_BM_Publish_method” by var=subs_count where size=1024 buffer=100
Benchmark name is “PublisherFixture/ROS_BM_Publish_method” by var=subs_count where size=1024 buffer=1000
Benchmark name is “PublisherFixture/ROS_BM_Publish_method” by var=subs_count where size=1024 buffer=10000
Benchmark name is “PublisherFixture/ROS_BM_Publish_method” by var=subs_count where size=4096 buffer=1
Benchmark name is “PublisherFixture/ROS_BM_Publish_method” by var=subs_count where size=4096 buffer=10
Benchmark name is “PublisherFixture/ROS_BM_Publish_method” by var=subs_count where size=4096 buffer=100
Benchmark name is “PublisherFixture/ROS_BM_Publish_method” by var=subs_count where size=4096 buffer=1000
Benchmark name is “PublisherFixture/ROS_BM_Publish_method” by var=subs_count where size=4096 buffer=10000
Benchmark name is “PublisherFixture/ROS_BM_Publish_method” by var=subs_count where size=16384 buffer=1
Benchmark name is “PublisherFixture/ROS_BM_Publish_method” by var=subs_count where size=16384 buffer=10
Benchmark name is “PublisherFixture/ROS_BM_Publish_method” by var=subs_count where size=16384 buffer=100
Benchmark name is “PublisherFixture/ROS_BM_Publish_method” by var=subs_count where size=16384 buffer=1000
Benchmark name is “PublisherFixture/ROS_BM_Publish_method” by var=subs_count where size=16384 buffer=10000
Benchmark name is “PublisherFixture/ROS_BM_Publish_method” by var=subs_count where size=65536 buffer=1
Benchmark name is “PublisherFixture/ROS_BM_Publish_method” by var=subs_count where size=65536 buffer=10
Benchmark name is “PublisherFixture/ROS_BM_Publish_method” by var=subs_count where size=65536 buffer=100
Benchmark name is “PublisherFixture/ROS_BM_Publish_method” by var=subs_count where size=65536 buffer=1000
Benchmark name is “PublisherFixture/ROS_BM_Publish_method” by var=subs_count where size=65536 buffer=10000
Benchmark name is “PublisherFixture/ROS_BM_Publish_method” by var=subs_count where size=262144 buffer=1
Benchmark name is “PublisherFixture/ROS_BM_Publish_method” by var=subs_count where size=262144 buffer=10
Benchmark name is “PublisherFixture/ROS_BM_Publish_method” by var=subs_count where size=262144 buffer=100
Benchmark name is “PublisherFixture/ROS_BM_Publish_method” by var=subs_count where size=262144 buffer=1000
Benchmark name is “PublisherFixture/ROS_BM_Publish_method” by var=subs_count where size=262144 buffer=10000
Benchmark name is “PublisherFixture/ROS_BM_Publish_method” by var=subs_count where size=1048576 buffer=1
Benchmark name is “PublisherFixture/ROS_BM_Publish_method” by var=subs_count where size=1048576 buffer=10
Benchmark name is “PublisherFixture/ROS_BM_Publish_method” by var=subs_count where size=1048576 buffer=100
Benchmark name is “PublisherFixture/ROS_BM_Publish_method” by var=subs_count where size=1048576 buffer=1000
Benchmark name is “PublisherFixture/ROS_BM_Publish_method” by var=subs_count where size=1048576 buffer=10000
Benchmark name is “PublisherFixture/ROS_BM_Publish_method” by var=subs_count where size=4194304 buffer=1
Benchmark name is “PublisherFixture/ROS_BM_Publish_method” by var=subs_count where size=4194304 buffer=10
Benchmark name is “PublisherFixture/ROS_BM_Publish_method” by var=subs_count where size=4194304 buffer=100
Benchmark name is “PublisherFixture/ROS_BM_Publish_method” by var=subs_count where size=4194304 buffer=1000
Benchmark name is “PublisherFixture/ROS_BM_Publish_method” by var=subs_count where size=4194304 buffer=10000
Benchmark name is “PublisherFixture/ROS_BM_Publish_method” by var=subs_count where size=16777216 buffer=1
Benchmark name is “PublisherFixture/ROS_BM_Publish_method” by var=subs_count where size=16777216 buffer=10
Benchmark name is “PublisherFixture/ROS_BM_Publish_method” by var=subs_count where size=16777216 buffer=100
Benchmark name is “PublisherFixture/ROS_BM_Publish_method” by var=subs_count where size=16777216 buffer=1000
Benchmark name is “PublisherFixture/ROS_BM_Publish_method” by var=subs_count where size=16777216 buffer=10000
Benchmark name is “PublisherFixture/ROS_BM_Publish_method” by var=subs_count where size=67108864 buffer=1
Benchmark name is “PublisherFixture/ROS_BM_Publish_method” by var=subs_count where size=67108864 buffer=10
Benchmark name is “PublisherFixture/ROS_BM_Publish_method” by var=subs_count where size=67108864 buffer=100
Benchmark name is “PublisherFixture/ROS_BM_Publish_method” by var=subs_count where size=67108864 buffer=1000
Benchmark name is “PublisherFixture/ROS_BM_Publish_method” by var=subs_count where size=67108864 buffer=10000
Benchmark name is “PublisherFixture/ROS_BM_Publish_method” by var=size where subs_count=1 buffer=1
Benchmark name is “PublisherFixture/ROS_BM_Publish_method” by var=size where subs_count=1 buffer=10
Benchmark name is “PublisherFixture/ROS_BM_Publish_method” by var=size where subs_count=1 buffer=100
Benchmark name is “PublisherFixture/ROS_BM_Publish_method” by var=size where subs_count=1 buffer=1000
Benchmark name is “PublisherFixture/ROS_BM_Publish_method” by var=size where subs_count=1 buffer=10000
Benchmark name is “PublisherFixture/ROS_BM_Publish_method” by var=size where subs_count=2 buffer=1
Benchmark name is “PublisherFixture/ROS_BM_Publish_method” by var=size where subs_count=2 buffer=10
Benchmark name is “PublisherFixture/ROS_BM_Publish_method” by var=size where subs_count=2 buffer=100
Benchmark name is “PublisherFixture/ROS_BM_Publish_method” by var=size where subs_count=2 buffer=1000
Benchmark name is “PublisherFixture/ROS_BM_Publish_method” by var=size where subs_count=2 buffer=10000
Benchmark name is “PublisherFixture/ROS_BM_Publish_method” by var=size where subs_count=4 buffer=1
Benchmark name is “PublisherFixture/ROS_BM_Publish_method” by var=size where subs_count=4 buffer=10
Benchmark name is “PublisherFixture/ROS_BM_Publish_method” by var=size where subs_count=4 buffer=100
Benchmark name is “PublisherFixture/ROS_BM_Publish_method” by var=size where subs_count=4 buffer=1000
Benchmark name is “PublisherFixture/ROS_BM_Publish_method” by var=size where subs_count=4 buffer=10000
Benchmark name is “PublisherFixture/ROS_BM_Publish_method” by var=size where subs_count=8 buffer=1
Benchmark name is “PublisherFixture/ROS_BM_Publish_method” by var=size where subs_count=8 buffer=10
Benchmark name is “PublisherFixture/ROS_BM_Publish_method” by var=size where subs_count=8 buffer=100
Benchmark name is “PublisherFixture/ROS_BM_Publish_method” by var=size where subs_count=8 buffer=1000
Benchmark name is “PublisherFixture/ROS_BM_Publish_method” by var=size where subs_count=8 buffer=10000
Benchmark name is “PublisherFixture/ROS_BM_Publish_method” by var=buffer where subs_count=1 size=1024
Benchmark name is “PublisherFixture/ROS_BM_Publish_method” by var=buffer where subs_count=1 size=4096
Benchmark name is “PublisherFixture/ROS_BM_Publish_method” by var=buffer where subs_count=1 size=16384
Benchmark name is “PublisherFixture/ROS_BM_Publish_method” by var=buffer where subs_count=1 size=65536
Benchmark name is “PublisherFixture/ROS_BM_Publish_method” by var=buffer where subs_count=1 size=262144
Benchmark name is “PublisherFixture/ROS_BM_Publish_method” by var=buffer where subs_count=1 size=1048576
Benchmark name is “PublisherFixture/ROS_BM_Publish_method” by var=buffer where subs_count=1 size=4194304
Benchmark name is “PublisherFixture/ROS_BM_Publish_method” by var=buffer where subs_count=1 size=16777216
Benchmark name is “PublisherFixture/ROS_BM_Publish_method” by var=buffer where subs_count=1 size=67108864
Benchmark name is “PublisherFixture/ROS_BM_Publish_method” by var=buffer where subs_count=2 size=1024
Benchmark name is “PublisherFixture/ROS_BM_Publish_method” by var=buffer where subs_count=2 size=4096
Benchmark name is “PublisherFixture/ROS_BM_Publish_method” by var=buffer where subs_count=2 size=16384
Benchmark name is “PublisherFixture/ROS_BM_Publish_method” by var=buffer where subs_count=2 size=65536
Benchmark name is “PublisherFixture/ROS_BM_Publish_method” by var=buffer where subs_count=2 size=262144
Benchmark name is “PublisherFixture/ROS_BM_Publish_method” by var=buffer where subs_count=2 size=1048576
Benchmark name is “PublisherFixture/ROS_BM_Publish_method” by var=buffer where subs_count=2 size=4194304
Benchmark name is “PublisherFixture/ROS_BM_Publish_method” by var=buffer where subs_count=2 size=16777216
Benchmark name is “PublisherFixture/ROS_BM_Publish_method” by var=buffer where subs_count=2 size=67108864
Benchmark name is “PublisherFixture/ROS_BM_Publish_method” by var=buffer where subs_count=4 size=1024
Benchmark name is “PublisherFixture/ROS_BM_Publish_method” by var=buffer where subs_count=4 size=4096
Benchmark name is “PublisherFixture/ROS_BM_Publish_method” by var=buffer where subs_count=4 size=16384
Benchmark name is “PublisherFixture/ROS_BM_Publish_method” by var=buffer where subs_count=4 size=65536
Benchmark name is “PublisherFixture/ROS_BM_Publish_method” by var=buffer where subs_count=4 size=262144
Benchmark name is “PublisherFixture/ROS_BM_Publish_method” by var=buffer where subs_count=4 size=1048576
Benchmark name is “PublisherFixture/ROS_BM_Publish_method” by var=buffer where subs_count=4 size=4194304
Benchmark name is “PublisherFixture/ROS_BM_Publish_method” by var=buffer where subs_count=4 size=16777216
Benchmark name is “PublisherFixture/ROS_BM_Publish_method” by var=buffer where subs_count=4 size=67108864
Benchmark name is “PublisherFixture/ROS_BM_Publish_method” by var=buffer where subs_count=8 size=1024
Benchmark name is “PublisherFixture/ROS_BM_Publish_method” by var=buffer where subs_count=8 size=4096
Benchmark name is “PublisherFixture/ROS_BM_Publish_method” by var=buffer where subs_count=8 size=16384
Benchmark name is “PublisherFixture/ROS_BM_Publish_method” by var=buffer where subs_count=8 size=65536
Benchmark name is “PublisherFixture/ROS_BM_Publish_method” by var=buffer where subs_count=8 size=262144
Benchmark name is “PublisherFixture/ROS_BM_Publish_method” by var=buffer where subs_count=8 size=1048576
Benchmark name is “PublisherFixture/ROS_BM_Publish_method” by var=buffer where subs_count=8 size=4194304
Benchmark name is “PublisherFixture/ROS_BM_Publish_method” by var=buffer where subs_count=8 size=16777216
Benchmark name is “PublisherFixture/ROS_BM_Publish_method” by var=buffer where subs_count=8 size=67108864
Benchmark name is “ClientFixture/ROS_BM_Service” by var=size where

Benchmark name is “PublisherFixture/ROS_BM_Publish_method” by var=subs_count where size=1024 buffer=1

#png(filename="plot.png", width = 1600, height = 900)
subs_count <- c(1, 2, 4, 8)
real_time <- c(4580.186172553285, 5157.011854205701, 4684.410036701205, 6249.40646490663)
cpu_time <- c(3979.014066657179, 4074.007642896597, 3339.426264617111, 3039.782576182089)
bytes_per_second <- c(223577799.00550812, 397220849.88300574, 874634945.652821, 1332488547.6901639)
manual_bandwidth <- c(285570646.1227563, 488726486.6053093, 33317737593.986713, 63697450779.432655)
manual_latency <- c(100541167.69730183, 82142198.40676616, 3587458.8356091543, 2062459.5037345835)
df <- data.frame("factor"=subs_count, "Время отправки (нс)"=real_time, "Время отправки CPU (нс)"=cpu_time, "Широта пропускания публикующего (б/с)"=bytes_per_second, "Широта пропускания принимающего (б/с)"=manual_bandwidth, "Задержка передачи (нс)"=manual_latency)
plot(factor(subs_count, levels=subs_count), real_time, type="o", col="black", lty=0, ylim=c(239.40983080255637, 9049.779210286164), xlab="", ylab="")
points(factor(subs_count, levels=subs_count), real_time, col="black", pch="o")
lines(factor(subs_count, levels=subs_count), real_time, col="black", lty=1, lwd=2)
title(main="Зависимость задержки от фактора", xlab="Кол-во подписчиков", ylab="Задержка (нс)")
points(factor(subs_count, levels=subs_count), cpu_time, col="red", pch="X")
lines(factor(subs_count, levels=subs_count), cpu_time, col="red", lty=2, lwd=2)
legend("bottomright", legend=c("Время отправки (нс)", "Время отправки CPU (нс)"), col=c("black", "red"), lty=c(1, 2), pch=c("o", "X"), ncol=1)

plot(factor(subs_count, levels=subs_count), bytes_per_second, type="o", col="black", lty=0, ylim=c(-48012115913.64952, 111933144492.08768), xlab="", ylab="")
points(factor(subs_count, levels=subs_count), bytes_per_second, col="black", pch="o")
lines(factor(subs_count, levels=subs_count), bytes_per_second, col="black", lty=1, lwd=2)
title(main="Зависимость широты пропускания от фактора", xlab="Кол-во подписчиков", ylab="Широта пропускания (байт/сек)")
text( factor(subs_count, levels=subs_count), bytes_per_second, labels=bytes_per_second, cex= 0.7, pos=3)
points(factor(subs_count, levels=subs_count), manual_bandwidth, col="red", pch="X")
lines(factor(subs_count, levels=subs_count), manual_bandwidth, col="red", lty=2, lwd=2)
text( factor(subs_count, levels=subs_count), manual_bandwidth, labels=manual_bandwidth, cex= 0.7, pos=3)
legend("bottomright", legend=c("Широта пропускания публикующего (б/с)", "Широта пропускания принимающего (б/с)"), col=c("black", "red"), lty=c(1, 2), pch=c("o", "X"), ncol=1)

Benchmark name is “PublisherFixture/ROS_BM_Publish_method” by var=subs_count where size=1024 buffer=10

#png(filename="plot.png", width = 1600, height = 900)
subs_count <- c(1, 2, 4, 8)
real_time <- c(4682.1144877890165, 4786.512908634228, 4605.697632950371, 6107.915192913591)
cpu_time <- c(4022.6201363443483, 3977.817551199181, 3347.2170040059764, 3005.5745473444526)
bytes_per_second <- c(218715403.4698433, 427877594.2851998, 889338766.6675043, 1356733573.9255395)
manual_bandwidth <- c(266508563.34648475, 13510473485.041466, 38957175762.18716, 54151966031.10595)
manual_latency <- c(89514370.37282008, 3681929.9947898104, 2653355.2797045363, 2086203.3690450503)
df <- data.frame("factor"=subs_count, "Время отправки (нс)"=real_time, "Время отправки CPU (нс)"=cpu_time, "Широта пропускания публикующего (б/с)"=bytes_per_second, "Широта пропускания принимающего (б/с)"=manual_bandwidth, "Задержка передачи (нс)"=manual_latency)
plot(factor(subs_count, levels=subs_count), real_time, type="o", col="black", lty=0, ylim=c(453.9468768297752, 8659.542863428269), xlab="", ylab="")
points(factor(subs_count, levels=subs_count), real_time, col="black", pch="o")
lines(factor(subs_count, levels=subs_count), real_time, col="black", lty=1, lwd=2)
title(main="Зависимость задержки от фактора", xlab="Кол-во подписчиков", ylab="Задержка (нс)")
points(factor(subs_count, levels=subs_count), cpu_time, col="red", pch="X")
lines(factor(subs_count, levels=subs_count), cpu_time, col="red", lty=2, lwd=2)
legend("bottomright", legend=c("Время отправки (нс)", "Время отправки CPU (нс)"), col=c("black", "red"), lty=c(1, 2), pch=c("o", "X"), ncol=1)

plot(factor(subs_count, levels=subs_count), bytes_per_second, type="o", col="black", lty=0, ylim=c(-34475364108.77897, 88846045543.35477), xlab="", ylab="")
points(factor(subs_count, levels=subs_count), bytes_per_second, col="black", pch="o")
lines(factor(subs_count, levels=subs_count), bytes_per_second, col="black", lty=1, lwd=2)
title(main="Зависимость широты пропускания от фактора", xlab="Кол-во подписчиков", ylab="Широта пропускания (байт/сек)")
text( factor(subs_count, levels=subs_count), bytes_per_second, labels=bytes_per_second, cex= 0.7, pos=3)
points(factor(subs_count, levels=subs_count), manual_bandwidth, col="red", pch="X")
lines(factor(subs_count, levels=subs_count), manual_bandwidth, col="red", lty=2, lwd=2)
text( factor(subs_count, levels=subs_count), manual_bandwidth, labels=manual_bandwidth, cex= 0.7, pos=3)
legend("bottomright", legend=c("Широта пропускания публикующего (б/с)", "Широта пропускания принимающего (б/с)"), col=c("black", "red"), lty=c(1, 2), pch=c("o", "X"), ncol=1)

Benchmark name is “PublisherFixture/ROS_BM_Publish_method” by var=subs_count where size=1024 buffer=100

#png(filename="plot.png", width = 1600, height = 900)
subs_count <- c(1, 2, 4, 8)
real_time <- c(4696.130734695629, 4788.4441863204265, 4624.482520685689, 5992.174665681887)
cpu_time <- c(4043.0389562330433, 3942.1589292166345, 3307.0349335376313, 3013.767389001032)
bytes_per_second <- c(218059518.18379253, 427712338.78835094, 885769097.0603113, 1376222131.676145)
manual_bandwidth <- c(295981091.74113256, 11753311273.55764, 27310638125.28106, 40397784930.94996)
manual_latency <- c(98827380.76116, 5016327.149989426, 6639831.718454286, 2136194.208640861)
df <- data.frame("factor"=subs_count, "Время отправки (нс)"=real_time, "Время отправки CPU (нс)"=cpu_time, "Широта пропускания публикующего (б/с)"=bytes_per_second, "Широта пропускания принимающего (б/с)"=manual_bandwidth, "Задержка передачи (нс)"=manual_latency)
plot(factor(subs_count, levels=subs_count), real_time, type="o", col="black", lty=0, ylim=c(789.3230335920498, 8216.619021090868), xlab="", ylab="")
points(factor(subs_count, levels=subs_count), real_time, col="black", pch="o")
lines(factor(subs_count, levels=subs_count), real_time, col="black", lty=1, lwd=2)
title(main="Зависимость задержки от фактора", xlab="Кол-во подписчиков", ylab="Задержка (нс)")
points(factor(subs_count, levels=subs_count), cpu_time, col="red", pch="X")
lines(factor(subs_count, levels=subs_count), cpu_time, col="red", lty=2, lwd=2)
legend("bottomright", legend=c("Время отправки (нс)", "Время отправки CPU (нс)"), col=c("black", "red"), lty=c(1, 2), pch=c("o", "X"), ncol=1)

plot(factor(subs_count, levels=subs_count), bytes_per_second, type="o", col="black", lty=0, ylim=c(-38232815736.25281, 78848660185.38657), xlab="", ylab="")
points(factor(subs_count, levels=subs_count), bytes_per_second, col="black", pch="o")
lines(factor(subs_count, levels=subs_count), bytes_per_second, col="black", lty=1, lwd=2)
title(main="Зависимость широты пропускания от фактора", xlab="Кол-во подписчиков", ylab="Широта пропускания (байт/сек)")
text( factor(subs_count, levels=subs_count), bytes_per_second, labels=bytes_per_second, cex= 0.7, pos=3)
points(factor(subs_count, levels=subs_count), manual_bandwidth, col="red", pch="X")
lines(factor(subs_count, levels=subs_count), manual_bandwidth, col="red", lty=2, lwd=2)
text( factor(subs_count, levels=subs_count), manual_bandwidth, labels=manual_bandwidth, cex= 0.7, pos=3)
legend("bottomright", legend=c("Широта пропускания публикующего (б/с)", "Широта пропускания принимающего (б/с)"), col=c("black", "red"), lty=c(1, 2), pch=c("o", "X"), ncol=1)

Benchmark name is “PublisherFixture/ROS_BM_Publish_method” by var=subs_count where size=1024 buffer=1000

#png(filename="plot.png", width = 1600, height = 900)
subs_count <- c(1, 2, 4, 8)
real_time <- c(4647.609275461621, 4785.349781783731, 4712.889624609076, 6057.0764683186035)
cpu_time <- c(3996.525072522072, 3949.1776102545314, 3370.339144370778, 3008.9449492888198)
bytes_per_second <- c(220334104.45400634, 427979202.6862031, 869127377.0770099, 1364425590.406985)
manual_bandwidth <- c(233548707.55889267, 11971461234.445177, 23581343245.885048, 42677174734.15156)
manual_latency <- c(98645086.48662971, 4393799.865931442, 6253900.006806096, 1986702.089213444)
df <- data.frame("factor"=subs_count, "Время отправки (нс)"=real_time, "Время отправки CPU (нс)"=cpu_time, "Широта пропускания публикующего (б/с)"=bytes_per_second, "Широта пропускания принимающего (б/с)"=manual_bandwidth, "Задержка передачи (нс)"=manual_latency)
plot(factor(subs_count, levels=subs_count), real_time, type="o", col="black", lty=0, ylim=c(620.5692079216428, 8445.45220968578), xlab="", ylab="")
points(factor(subs_count, levels=subs_count), real_time, col="black", pch="o")
lines(factor(subs_count, levels=subs_count), real_time, col="black", lty=1, lwd=2)
title(main="Зависимость задержки от фактора", xlab="Кол-во подписчиков", ylab="Задержка (нс)")
points(factor(subs_count, levels=subs_count), cpu_time, col="red", pch="X")
lines(factor(subs_count, levels=subs_count), cpu_time, col="red", lty=2, lwd=2)
legend("bottomright", legend=c("Время отправки (нс)", "Время отправки CPU (нс)"), col=c("black", "red"), lty=c(1, 2), pch=c("o", "X"), ncol=1)

plot(factor(subs_count, levels=subs_count), bytes_per_second, type="o", col="black", lty=0, ylim=c(-35298418417.0779, 78195927255.68347), xlab="", ylab="")
points(factor(subs_count, levels=subs_count), bytes_per_second, col="black", pch="o")
lines(factor(subs_count, levels=subs_count), bytes_per_second, col="black", lty=1, lwd=2)
title(main="Зависимость широты пропускания от фактора", xlab="Кол-во подписчиков", ylab="Широта пропускания (байт/сек)")
text( factor(subs_count, levels=subs_count), bytes_per_second, labels=bytes_per_second, cex= 0.7, pos=3)
points(factor(subs_count, levels=subs_count), manual_bandwidth, col="red", pch="X")
lines(factor(subs_count, levels=subs_count), manual_bandwidth, col="red", lty=2, lwd=2)
text( factor(subs_count, levels=subs_count), manual_bandwidth, labels=manual_bandwidth, cex= 0.7, pos=3)
legend("bottomright", legend=c("Широта пропускания публикующего (б/с)", "Широта пропускания принимающего (б/с)"), col=c("black", "red"), lty=c(1, 2), pch=c("o", "X"), ncol=1)

Benchmark name is “PublisherFixture/ROS_BM_Publish_method” by var=subs_count where size=1024 buffer=10000

#png(filename="plot.png", width = 1600, height = 900)
subs_count <- c(1, 2, 4, 8)
real_time <- c(4677.977688931564, 4820.713313170985, 4587.953994373003, 5982.318517967719)
cpu_time <- c(4032.751272340824, 3975.039859758196, 3237.9827143256225, 3003.2941593931237)
bytes_per_second <- c(218914227.22643536, 425490283.8058814, 892897826.9535488, 1387171478.396817)
manual_bandwidth <- c(289649824.28957945, 7387770172.393695, 16273678924.709589, 43473444560.08747)
manual_latency <- c(99219020.04579222, 13871864.109881664, 20032105.41607633, 2202890.4056161502)
df <- data.frame("factor"=subs_count, "Время отправки (нс)"=real_time, "Время отправки CPU (нс)"=cpu_time, "Широта пропускания публикующего (б/с)"=bytes_per_second, "Широта пропускания принимающего (б/с)"=manual_bandwidth, "Задержка передачи (нс)"=manual_latency)
plot(factor(subs_count, levels=subs_count), real_time, type="o", col="black", lty=0, ylim=c(493.11267036071763, 8492.500007000126), xlab="", ylab="")
points(factor(subs_count, levels=subs_count), real_time, col="black", pch="o")
lines(factor(subs_count, levels=subs_count), real_time, col="black", lty=1, lwd=2)
title(main="Зависимость задержки от фактора", xlab="Кол-во подписчиков", ylab="Задержка (нс)")
points(factor(subs_count, levels=subs_count), cpu_time, col="red", pch="X")
lines(factor(subs_count, levels=subs_count), cpu_time, col="red", lty=2, lwd=2)
legend("bottomright", legend=c("Время отправки (нс)", "Время отправки CPU (нс)"), col=c("black", "red"), lty=c(1, 2), pch=c("o", "X"), ncol=1)

plot(factor(subs_count, levels=subs_count), bytes_per_second, type="o", col="black", lty=0, ylim=c(-38747295125.28782, 82439653912.60173), xlab="", ylab="")
points(factor(subs_count, levels=subs_count), bytes_per_second, col="black", pch="o")
lines(factor(subs_count, levels=subs_count), bytes_per_second, col="black", lty=1, lwd=2)
title(main="Зависимость широты пропускания от фактора", xlab="Кол-во подписчиков", ylab="Широта пропускания (байт/сек)")
text( factor(subs_count, levels=subs_count), bytes_per_second, labels=bytes_per_second, cex= 0.7, pos=3)
points(factor(subs_count, levels=subs_count), manual_bandwidth, col="red", pch="X")
lines(factor(subs_count, levels=subs_count), manual_bandwidth, col="red", lty=2, lwd=2)
text( factor(subs_count, levels=subs_count), manual_bandwidth, labels=manual_bandwidth, cex= 0.7, pos=3)
legend("bottomright", legend=c("Широта пропускания публикующего (б/с)", "Широта пропускания принимающего (б/с)"), col=c("black", "red"), lty=c(1, 2), pch=c("o", "X"), ncol=1)

Benchmark name is “PublisherFixture/ROS_BM_Publish_method” by var=subs_count where size=4096 buffer=1

#png(filename="plot.png", width = 1600, height = 900)
subs_count <- c(1, 2, 4, 8)
real_time <- c(5141.29448106764, 5066.614075190955, 5346.713790906761, 5298.868434206353)
cpu_time <- c(4555.869325588748, 4390.646898982709, 4312.555429542455, 3282.7024012936004)
bytes_per_second <- c(796736934.3596822, 1617027284.1902287, 3064724132.7861276, 6248669858.39148)
manual_bandwidth <- c(562460814.8161839, 868839785.6372092, 2329416068.3462152, 29743578193.40341)
manual_latency <- c(73825278.00071314, 69236999.46569867, 69984912.93569992, 7468308.709027636)
df <- data.frame("factor"=subs_count, "Время отправки (нс)"=real_time, "Время отправки CPU (нс)"=cpu_time, "Широта пропускания публикующего (б/с)"=bytes_per_second, "Широта пропускания принимающего (б/с)"=manual_bandwidth, "Задержка передачи (нс)"=manual_latency)
plot(factor(subs_count, levels=subs_count), real_time, type="o", col="black", lty=0, ylim=c(1449.8626143118188, 7179.553577888542), xlab="", ylab="")
points(factor(subs_count, levels=subs_count), real_time, col="black", pch="o")
lines(factor(subs_count, levels=subs_count), real_time, col="black", lty=1, lwd=2)
title(main="Зависимость задержки от фактора", xlab="Кол-во подписчиков", ylab="Задержка (нс)")
points(factor(subs_count, levels=subs_count), cpu_time, col="red", pch="X")
lines(factor(subs_count, levels=subs_count), cpu_time, col="red", lty=2, lwd=2)
legend("bottomright", legend=c("Время отправки (нс)", "Время отправки CPU (нс)"), col=c("black", "red"), lty=c(1, 2), pch=c("o", "X"), ncol=1)

plot(factor(subs_count, levels=subs_count), bytes_per_second, type="o", col="black", lty=0, ylim=c(-36214625381.340096, 66520664389.55969), xlab="", ylab="")
points(factor(subs_count, levels=subs_count), bytes_per_second, col="black", pch="o")
lines(factor(subs_count, levels=subs_count), bytes_per_second, col="black", lty=1, lwd=2)
title(main="Зависимость широты пропускания от фактора", xlab="Кол-во подписчиков", ylab="Широта пропускания (байт/сек)")
text( factor(subs_count, levels=subs_count), bytes_per_second, labels=bytes_per_second, cex= 0.7, pos=3)
points(factor(subs_count, levels=subs_count), manual_bandwidth, col="red", pch="X")
lines(factor(subs_count, levels=subs_count), manual_bandwidth, col="red", lty=2, lwd=2)
text( factor(subs_count, levels=subs_count), manual_bandwidth, labels=manual_bandwidth, cex= 0.7, pos=3)
legend("bottomright", legend=c("Широта пропускания публикующего (б/с)", "Широта пропускания принимающего (б/с)"), col=c("black", "red"), lty=c(1, 2), pch=c("o", "X"), ncol=1)

Benchmark name is “PublisherFixture/ROS_BM_Publish_method” by var=subs_count where size=4096 buffer=10

#png(filename="plot.png", width = 1600, height = 900)
subs_count <- c(1, 2, 4, 8)
real_time <- c(5086.4825499693825, 5010.18803186704, 5367.284222920496, 5084.288325373656)
cpu_time <- c(4520.956539210994, 4358.697393979326, 4326.7471633898185, 3203.3299574278667)
bytes_per_second <- c(805315086.1682184, 1635137728.5418162, 3053003432.596627, 6520187621.122169)
manual_bandwidth <- c(541051935.4185402, 1189163222.6229599, 2381763236.2732363, 35891918134.00308)
manual_latency <- c(77874221.18243358, 69397024.38562232, 71100658.07463613, 6915341.520207157)
df <- data.frame("factor"=subs_count, "Время отправки (нс)"=real_time, "Время отправки CPU (нс)"=cpu_time, "Широта пропускания публикующего (б/с)"=bytes_per_second, "Широта пропускания принимающего (б/с)"=manual_bandwidth, "Задержка передачи (нс)"=manual_latency)
plot(factor(subs_count, levels=subs_count), real_time, type="o", col="black", lty=0, ylim=c(1275.3042708502296, 7295.3099094981335), xlab="", ylab="")
points(factor(subs_count, levels=subs_count), real_time, col="black", pch="o")
lines(factor(subs_count, levels=subs_count), real_time, col="black", lty=1, lwd=2)
title(main="Зависимость задержки от фактора", xlab="Кол-во подписчиков", ylab="Задержка (нс)")
points(factor(subs_count, levels=subs_count), cpu_time, col="red", pch="X")
lines(factor(subs_count, levels=subs_count), cpu_time, col="red", lty=2, lwd=2)
legend("bottomright", legend=c("Время отправки (нс)", "Время отправки CPU (нс)"), col=c("black", "red"), lty=c(1, 2), pch=c("o", "X"), ncol=1)

plot(factor(subs_count, levels=subs_count), bytes_per_second, type="o", col="black", lty=0, ylim=c(-47902694562.17991, 84335664631.60153), xlab="", ylab="")
points(factor(subs_count, levels=subs_count), bytes_per_second, col="black", pch="o")
lines(factor(subs_count, levels=subs_count), bytes_per_second, col="black", lty=1, lwd=2)
title(main="Зависимость широты пропускания от фактора", xlab="Кол-во подписчиков", ylab="Широта пропускания (байт/сек)")
text( factor(subs_count, levels=subs_count), bytes_per_second, labels=bytes_per_second, cex= 0.7, pos=3)
points(factor(subs_count, levels=subs_count), manual_bandwidth, col="red", pch="X")
lines(factor(subs_count, levels=subs_count), manual_bandwidth, col="red", lty=2, lwd=2)
text( factor(subs_count, levels=subs_count), manual_bandwidth, labels=manual_bandwidth, cex= 0.7, pos=3)
legend("bottomright", legend=c("Широта пропускания публикующего (б/с)", "Широта пропускания принимающего (б/с)"), col=c("black", "red"), lty=c(1, 2), pch=c("o", "X"), ncol=1)

Benchmark name is “PublisherFixture/ROS_BM_Publish_method” by var=subs_count where size=4096 buffer=100

#png(filename="plot.png", width = 1600, height = 900)
subs_count <- c(1, 2, 4, 8)
real_time <- c(4996.712260876187, 4992.848741784826, 5399.78996214403, 5359.818269381755)
cpu_time <- c(4484.187911371033, 4342.987223008087, 4343.02291016358, 3295.026563652607)
bytes_per_second <- c(819773825.8472631, 1640815507.0075707, 3034455990.8642945, 6252563254.584262)
manual_bandwidth <- c(519480747.8371477, 1051863292.1080315, 2033944234.4771824, 22344468241.77512)
manual_latency <- c(78586582.6695374, 77179944.7658565, 64148483.550389096, 10212650.896962786)
df <- data.frame("factor"=subs_count, "Время отправки (нс)"=real_time, "Время отправки CPU (нс)"=cpu_time, "Широта пропускания публикующего (б/с)"=bytes_per_second, "Широта пропускания принимающего (б/с)"=manual_bandwidth, "Задержка передачи (нс)"=manual_latency)
plot(factor(subs_count, levels=subs_count), real_time, type="o", col="black", lty=0, ylim=c(1012.0399613378058, 7682.776564458832), xlab="", ylab="")
points(factor(subs_count, levels=subs_count), real_time, col="black", pch="o")
lines(factor(subs_count, levels=subs_count), real_time, col="black", lty=1, lwd=2)
title(main="Зависимость задержки от фактора", xlab="Кол-во подписчиков", ylab="Задержка (нс)")
points(factor(subs_count, levels=subs_count), cpu_time, col="red", pch="X")
lines(factor(subs_count, levels=subs_count), cpu_time, col="red", lty=2, lwd=2)
legend("bottomright", legend=c("Время отправки (нс)", "Время отправки CPU (нс)"), col=c("black", "red"), lty=c(1, 2), pch=c("o", "X"), ncol=1)

plot(factor(subs_count, levels=subs_count), bytes_per_second, type="o", col="black", lty=0, ylim=c(-26782017843.431705, 49645966833.043976), xlab="", ylab="")
points(factor(subs_count, levels=subs_count), bytes_per_second, col="black", pch="o")
lines(factor(subs_count, levels=subs_count), bytes_per_second, col="black", lty=1, lwd=2)
title(main="Зависимость широты пропускания от фактора", xlab="Кол-во подписчиков", ylab="Широта пропускания (байт/сек)")
text( factor(subs_count, levels=subs_count), bytes_per_second, labels=bytes_per_second, cex= 0.7, pos=3)
points(factor(subs_count, levels=subs_count), manual_bandwidth, col="red", pch="X")
lines(factor(subs_count, levels=subs_count), manual_bandwidth, col="red", lty=2, lwd=2)
text( factor(subs_count, levels=subs_count), manual_bandwidth, labels=manual_bandwidth, cex= 0.7, pos=3)
legend("bottomright", legend=c("Широта пропускания публикующего (б/с)", "Широта пропускания принимающего (б/с)"), col=c("black", "red"), lty=c(1, 2), pch=c("o", "X"), ncol=1)

Benchmark name is “PublisherFixture/ROS_BM_Publish_method” by var=subs_count where size=4096 buffer=1000

#png(filename="plot.png", width = 1600, height = 900)
subs_count <- c(1, 2, 4, 8)
real_time <- c(4914.350042001504, 5008.709241208635, 5361.902088942925, 5419.77171932831)
cpu_time <- c(4390.631452501739, 4355.563179992146, 4306.291444705461, 3309.6955330579476)
bytes_per_second <- c(833495450.3921818, 1635620657.844274, 3055941645.1282587, 6129241916.539861)
manual_bandwidth <- c(517619176.04281694, 769163817.824446, 2289535860.949351, 26025516391.198513)
manual_latency <- c(79166648.66358423, 77771458.24521479, 71400029.05294092, 6906430.322168343)
df <- data.frame("factor"=subs_count, "Время отправки (нс)"=real_time, "Время отправки CPU (нс)"=cpu_time, "Широта пропускания публикующего (б/с)"=bytes_per_second, "Широта пропускания принимающего (б/с)"=manual_bandwidth, "Задержка передачи (нс)"=manual_latency)
plot(factor(subs_count, levels=subs_count), real_time, type="o", col="black", lty=0, ylim=c(1261.2201885829663, 7468.24706380329), xlab="", ylab="")
points(factor(subs_count, levels=subs_count), real_time, col="black", pch="o")
lines(factor(subs_count, levels=subs_count), real_time, col="black", lty=1, lwd=2)
title(main="Зависимость задержки от фактора", xlab="Кол-во подписчиков", ylab="Задержка (нс)")
points(factor(subs_count, levels=subs_count), cpu_time, col="red", pch="X")
lines(factor(subs_count, levels=subs_count), cpu_time, col="red", lty=2, lwd=2)
legend("bottomright", legend=c("Время отправки (нс)", "Время отправки CPU (нс)"), col=c("black", "red"), lty=c(1, 2), pch=c("o", "X"), ncol=1)

plot(factor(subs_count, levels=subs_count), bytes_per_second, type="o", col="black", lty=0, ylim=c(-34224784311.749146, 60767919878.99048), xlab="", ylab="")
points(factor(subs_count, levels=subs_count), bytes_per_second, col="black", pch="o")
lines(factor(subs_count, levels=subs_count), bytes_per_second, col="black", lty=1, lwd=2)
title(main="Зависимость широты пропускания от фактора", xlab="Кол-во подписчиков", ylab="Широта пропускания (байт/сек)")
text( factor(subs_count, levels=subs_count), bytes_per_second, labels=bytes_per_second, cex= 0.7, pos=3)
points(factor(subs_count, levels=subs_count), manual_bandwidth, col="red", pch="X")
lines(factor(subs_count, levels=subs_count), manual_bandwidth, col="red", lty=2, lwd=2)
text( factor(subs_count, levels=subs_count), manual_bandwidth, labels=manual_bandwidth, cex= 0.7, pos=3)
legend("bottomright", legend=c("Широта пропускания публикующего (б/с)", "Широта пропускания принимающего (б/с)"), col=c("black", "red"), lty=c(1, 2), pch=c("o", "X"), ncol=1)

Benchmark name is “PublisherFixture/ROS_BM_Publish_method” by var=subs_count where size=4096 buffer=10000

#png(filename="plot.png", width = 1600, height = 900)
subs_count <- c(1, 2, 4, 8)
real_time <- c(4930.20967126802, 4968.031603459658, 5370.790820216232, 5512.324932717507)
cpu_time <- c(4406.624640378626, 4330.63404212249, 4327.178122762954, 3321.7468407977713)
bytes_per_second <- c(830833871.4981556, 1649071796.7249732, 3050739653.3870015, 5992100707.579203)
manual_bandwidth <- c(532817554.3644816, 1089872499.312002, 2156300520.061728, 38469930877.55172)
manual_latency <- c(78445081.83738217, 76338393.0376416, 64072438.99136543, 6342390.803027696)
df <- data.frame("factor"=subs_count, "Время отправки (нс)"=real_time, "Время отправки CPU (нс)"=cpu_time, "Широта пропускания публикующего (б/с)"=bytes_per_second, "Широта пропускания принимающего (б/с)"=manual_bandwidth, "Задержка передачи (нс)"=manual_latency)
plot(factor(subs_count, levels=subs_count), real_time, type="o", col="black", lty=0, ylim=c(1461.8532472954191, 7372.218526219859), xlab="", ylab="")
points(factor(subs_count, levels=subs_count), real_time, col="black", pch="o")
lines(factor(subs_count, levels=subs_count), real_time, col="black", lty=1, lwd=2)
title(main="Зависимость задержки от фактора", xlab="Кол-во подписчиков", ylab="Задержка (нс)")
points(factor(subs_count, levels=subs_count), cpu_time, col="red", pch="X")
lines(factor(subs_count, levels=subs_count), cpu_time, col="red", lty=2, lwd=2)
legend("bottomright", legend=c("Время отправки (нс)", "Время отправки CPU (нс)"), col=c("black", "red"), lty=c(1, 2), pch=c("o", "X"), ncol=1)

plot(factor(subs_count, levels=subs_count), bytes_per_second, type="o", col="black", lty=0, ylim=c(-35490739216.536934, 74493487648.45314), xlab="", ylab="")
points(factor(subs_count, levels=subs_count), bytes_per_second, col="black", pch="o")
lines(factor(subs_count, levels=subs_count), bytes_per_second, col="black", lty=1, lwd=2)
title(main="Зависимость широты пропускания от фактора", xlab="Кол-во подписчиков", ylab="Широта пропускания (байт/сек)")
text( factor(subs_count, levels=subs_count), bytes_per_second, labels=bytes_per_second, cex= 0.7, pos=3)
points(factor(subs_count, levels=subs_count), manual_bandwidth, col="red", pch="X")
lines(factor(subs_count, levels=subs_count), manual_bandwidth, col="red", lty=2, lwd=2)
text( factor(subs_count, levels=subs_count), manual_bandwidth, labels=manual_bandwidth, cex= 0.7, pos=3)
legend("bottomright", legend=c("Широта пропускания публикующего (б/с)", "Широта пропускания принимающего (б/с)"), col=c("black", "red"), lty=c(1, 2), pch=c("o", "X"), ncol=1)

Benchmark name is “PublisherFixture/ROS_BM_Publish_method” by var=subs_count where size=16384 buffer=1

#png(filename="plot.png", width = 1600, height = 900)
subs_count <- c(1, 2, 4, 8)
real_time <- c(11413.245646123949, 7521.461427117245, 12739.164268983752, 9692.959681376462)
cpu_time <- c(10687.832977406468, 6941.257041351013, 11534.677806046744, 8444.946042044916)
bytes_per_second <- c(1444943827.793212, 4405431196.978784, 5240856404.250961, 13571873267.218204)
manual_bandwidth <- c(4854025925.934568, 6882682990.76209, 13475766682.934181, 28856689590.871117)
manual_latency <- c(3676285.601414365, 35454693.13271073, 3373828.0174958035, 4243554.973943848)
df <- data.frame("factor"=subs_count, "Время отправки (нс)"=real_time, "Время отправки CPU (нс)"=cpu_time, "Широта пропускания публикующего (б/с)"=bytes_per_second, "Широта пропускания принимающего (б/с)"=manual_bandwidth, "Задержка передачи (нс)"=manual_latency)
plot(factor(subs_count, levels=subs_count), real_time, type="o", col="black", lty=0, ylim=c(1411.2541352788267, 18269.167175055936), xlab="", ylab="")
points(factor(subs_count, levels=subs_count), real_time, col="black", pch="o")
lines(factor(subs_count, levels=subs_count), real_time, col="black", lty=1, lwd=2)
title(main="Зависимость задержки от фактора", xlab="Кол-во подписчиков", ylab="Задержка (нс)")
points(factor(subs_count, levels=subs_count), cpu_time, col="red", pch="X")
lines(factor(subs_count, levels=subs_count), cpu_time, col="red", lty=2, lwd=2)
legend("bottomright", legend=c("Время отправки (нс)", "Время отправки CPU (нс)"), col=c("black", "red"), lty=c(1, 2), pch=c("o", "X"), ncol=1)

plot(factor(subs_count, levels=subs_count), bytes_per_second, type="o", col="black", lty=0, ylim=c(-25837344844.802235, 56138978263.46657), xlab="", ylab="")
points(factor(subs_count, levels=subs_count), bytes_per_second, col="black", pch="o")
lines(factor(subs_count, levels=subs_count), bytes_per_second, col="black", lty=1, lwd=2)
title(main="Зависимость широты пропускания от фактора", xlab="Кол-во подписчиков", ylab="Широта пропускания (байт/сек)")
text( factor(subs_count, levels=subs_count), bytes_per_second, labels=bytes_per_second, cex= 0.7, pos=3)
points(factor(subs_count, levels=subs_count), manual_bandwidth, col="red", pch="X")
lines(factor(subs_count, levels=subs_count), manual_bandwidth, col="red", lty=2, lwd=2)
text( factor(subs_count, levels=subs_count), manual_bandwidth, labels=manual_bandwidth, cex= 0.7, pos=3)
legend("bottomright", legend=c("Широта пропускания публикующего (б/с)", "Широта пропускания принимающего (б/с)"), col=c("black", "red"), lty=c(1, 2), pch=c("o", "X"), ncol=1)

Benchmark name is “PublisherFixture/ROS_BM_Publish_method” by var=subs_count where size=16384 buffer=10

#png(filename="plot.png", width = 1600, height = 900)
subs_count <- c(1, 2, 4, 8)
real_time <- c(10797.271739557818, 9648.827123774035, 8369.486783418668, 9742.235739851585)
cpu_time <- c(10110.794076117785, 8940.691778472941, 7545.14963636342, 8367.012479025318)
bytes_per_second <- c(1522427786.9583912, 3426325958.521861, 7923108962.661034, 13546676451.435375)
manual_bandwidth <- c(4244976091.8839583, 8547580529.917875, 11314477975.625984, 30231073262.137306)
manual_latency <- c(10023994.052193463, 6082395.292379005, 20053693.589383326, 5674405.101053295)
df <- data.frame("factor"=subs_count, "Время отправки (нс)"=real_time, "Время отправки CPU (нс)"=cpu_time, "Широта пропускания публикующего (б/с)"=bytes_per_second, "Широта пропускания принимающего (б/с)"=manual_bandwidth, "Задержка передачи (нс)"=manual_latency)
plot(factor(subs_count, levels=subs_count), real_time, type="o", col="black", lty=0, ylim=c(4477.94471093351, 13864.47666498773), xlab="", ylab="")
points(factor(subs_count, levels=subs_count), real_time, col="black", pch="o")
lines(factor(subs_count, levels=subs_count), real_time, col="black", lty=1, lwd=2)
title(main="Зависимость задержки от фактора", xlab="Кол-во подписчиков", ylab="Задержка (нс)")
points(factor(subs_count, levels=subs_count), cpu_time, col="red", pch="X")
lines(factor(subs_count, levels=subs_count), cpu_time, col="red", lty=2, lwd=2)
legend("bottomright", legend=c("Время отправки (нс)", "Время отправки CPU (нс)"), col=c("black", "red"), lty=c(1, 2), pch=c("o", "X"), ncol=1)

plot(factor(subs_count, levels=subs_count), bytes_per_second, type="o", col="black", lty=0, ylim=c(-31232637738.39633, 62986138787.49203), xlab="", ylab="")
points(factor(subs_count, levels=subs_count), bytes_per_second, col="black", pch="o")
lines(factor(subs_count, levels=subs_count), bytes_per_second, col="black", lty=1, lwd=2)
title(main="Зависимость широты пропускания от фактора", xlab="Кол-во подписчиков", ylab="Широта пропускания (байт/сек)")
text( factor(subs_count, levels=subs_count), bytes_per_second, labels=bytes_per_second, cex= 0.7, pos=3)
points(factor(subs_count, levels=subs_count), manual_bandwidth, col="red", pch="X")
lines(factor(subs_count, levels=subs_count), manual_bandwidth, col="red", lty=2, lwd=2)
text( factor(subs_count, levels=subs_count), manual_bandwidth, labels=manual_bandwidth, cex= 0.7, pos=3)
legend("bottomright", legend=c("Широта пропускания публикующего (б/с)", "Широта пропускания принимающего (б/с)"), col=c("black", "red"), lty=c(1, 2), pch=c("o", "X"), ncol=1)

Benchmark name is “PublisherFixture/ROS_BM_Publish_method” by var=subs_count where size=16384 buffer=100

#png(filename="plot.png", width = 1600, height = 900)
subs_count <- c(1, 2, 4, 8)
real_time <- c(9838.876178620927, 9307.297751659746, 9490.150547117206, 9684.345799853301)
cpu_time <- c(9185.984708335725, 8598.71304644371, 8535.646722518413, 8462.439291709787)
bytes_per_second <- c(1672845539.8542438, 3569727017.760775, 7128254019.550135, 13570170488.942522)
manual_bandwidth <- c(5039883825.957062, 7020589668.383814, 15768120639.365692, 37944143944.3015)
manual_latency <- c(6987833.432573368, 13708409.237381566, 18481973.565961625, 4025887.318404039)
df <- data.frame("factor"=subs_count, "Время отправки (нс)"=real_time, "Время отправки CPU (нс)"=cpu_time, "Широта пропускания публикующего (б/с)"=bytes_per_second, "Широта пропускания принимающего (б/с)"=manual_bandwidth, "Задержка передачи (нс)"=manual_latency)
plot(factor(subs_count, levels=subs_count), real_time, type="o", col="black", lty=0, ylim=c(5156.877206515165, 13144.438263815548), xlab="", ylab="")
points(factor(subs_count, levels=subs_count), real_time, col="black", pch="o")
lines(factor(subs_count, levels=subs_count), real_time, col="black", lty=1, lwd=2)
title(main="Зависимость задержки от фактора", xlab="Кол-во подписчиков", ylab="Задержка (нс)")
points(factor(subs_count, levels=subs_count), cpu_time, col="red", pch="X")
lines(factor(subs_count, levels=subs_count), cpu_time, col="red", lty=2, lwd=2)
legend("bottomright", legend=c("Время отправки (нс)", "Время отправки CPU (нс)"), col=c("black", "red"), lty=c(1, 2), pch=c("o", "X"), ncol=1)

plot(factor(subs_count, levels=subs_count), bytes_per_second, type="o", col="black", lty=0, ylim=c(-32304019329.65502, 71921008813.81076), xlab="", ylab="")
points(factor(subs_count, levels=subs_count), bytes_per_second, col="black", pch="o")
lines(factor(subs_count, levels=subs_count), bytes_per_second, col="black", lty=1, lwd=2)
title(main="Зависимость широты пропускания от фактора", xlab="Кол-во подписчиков", ylab="Широта пропускания (байт/сек)")
text( factor(subs_count, levels=subs_count), bytes_per_second, labels=bytes_per_second, cex= 0.7, pos=3)
points(factor(subs_count, levels=subs_count), manual_bandwidth, col="red", pch="X")
lines(factor(subs_count, levels=subs_count), manual_bandwidth, col="red", lty=2, lwd=2)
text( factor(subs_count, levels=subs_count), manual_bandwidth, labels=manual_bandwidth, cex= 0.7, pos=3)
legend("bottomright", legend=c("Широта пропускания публикующего (б/с)", "Широта пропускания принимающего (б/с)"), col=c("black", "red"), lty=c(1, 2), pch=c("o", "X"), ncol=1)

Benchmark name is “PublisherFixture/ROS_BM_Publish_method” by var=subs_count where size=16384 buffer=1000

#png(filename="plot.png", width = 1600, height = 900)
subs_count <- c(1, 2, 4, 8)
real_time <- c(10817.46587170375, 8786.187739685674, 10752.269587540362, 9419.618730980223)
cpu_time <- c(10111.225631437, 8123.481326494989, 9725.664769400386, 8141.305977483957)
bytes_per_second <- c(1552375281.0753336, 3791193511.2788916, 6292109405.968262, 13985284237.868042)
manual_bandwidth <- c(3521025198.331669, 6562330665.497423, 20973582784.367477, 28941633241.141136)
manual_latency <- c(12683969.933360163, 8357396.402100799, 7365034.737198986, 8342028.220107794)
df <- data.frame("factor"=subs_count, "Время отправки (нс)"=real_time, "Время отправки CPU (нс)"=cpu_time, "Широта пропускания публикующего (б/с)"=bytes_per_second, "Широта пропускания принимающего (б/с)"=manual_bandwidth, "Задержка передачи (нс)"=manual_latency)
plot(factor(subs_count, levels=subs_count), real_time, type="o", col="black", lty=0, ylim=c(3685.1635109070603, 15255.783687291678), xlab="", ylab="")
points(factor(subs_count, levels=subs_count), real_time, col="black", pch="o")
lines(factor(subs_count, levels=subs_count), real_time, col="black", lty=1, lwd=2)
title(main="Зависимость задержки от фактора", xlab="Кол-во подписчиков", ylab="Задержка (нс)")
points(factor(subs_count, levels=subs_count), cpu_time, col="red", pch="X")
lines(factor(subs_count, levels=subs_count), cpu_time, col="red", lty=2, lwd=2)
legend("bottomright", legend=c("Время отправки (нс)", "Время отправки CPU (нс)"), col=c("black", "red"), lty=c(1, 2), pch=c("o", "X"), ncol=1)

plot(factor(subs_count, levels=subs_count), bytes_per_second, type="o", col="black", lty=0, ylim=c(-33261639940.12109, 63755648462.33756), xlab="", ylab="")
points(factor(subs_count, levels=subs_count), bytes_per_second, col="black", pch="o")
lines(factor(subs_count, levels=subs_count), bytes_per_second, col="black", lty=1, lwd=2)
title(main="Зависимость широты пропускания от фактора", xlab="Кол-во подписчиков", ylab="Широта пропускания (байт/сек)")
text( factor(subs_count, levels=subs_count), bytes_per_second, labels=bytes_per_second, cex= 0.7, pos=3)
points(factor(subs_count, levels=subs_count), manual_bandwidth, col="red", pch="X")
lines(factor(subs_count, levels=subs_count), manual_bandwidth, col="red", lty=2, lwd=2)
text( factor(subs_count, levels=subs_count), manual_bandwidth, labels=manual_bandwidth, cex= 0.7, pos=3)
legend("bottomright", legend=c("Широта пропускания публикующего (б/с)", "Широта пропускания принимающего (б/с)"), col=c("black", "red"), lty=c(1, 2), pch=c("o", "X"), ncol=1)

Benchmark name is “PublisherFixture/ROS_BM_Publish_method” by var=subs_count where size=16384 buffer=10000

#png(filename="plot.png", width = 1600, height = 900)
subs_count <- c(1, 2, 4, 8)
real_time <- c(10032.899855836778, 8932.244906434218, 9245.790448701935, 9106.713305290123)
cpu_time <- c(9360.39266823885, 8256.99268562074, 8384.418419042242, 7877.725071927637)
bytes_per_second <- c(1634542267.3890026, 3687889300.5797815, 7115003107.011942, 14425173466.713476)
manual_bandwidth <- c(8555976419.073015, 8256254659.259003, 34989820869.9505, 34264764504.390495)
manual_latency <- c(4338464.470109924, 10419793.151907107, 2647378.1340222927, 5255394.743360797)
df <- data.frame("factor"=subs_count, "Время отправки (нс)"=real_time, "Время отправки CPU (нс)"=cpu_time, "Широта пропускания публикующего (б/с)"=bytes_per_second, "Широта пропускания принимающего (б/с)"=manual_bandwidth, "Задержка передачи (нс)"=manual_latency)
plot(factor(subs_count, levels=subs_count), real_time, type="o", col="black", lty=0, ylim=c(5837.24855320046, 12073.376374563955), xlab="", ylab="")
points(factor(subs_count, levels=subs_count), real_time, col="black", pch="o")
lines(factor(subs_count, levels=subs_count), real_time, col="black", lty=1, lwd=2)
title(main="Зависимость задержки от фактора", xlab="Кол-во подписчиков", ylab="Задержка (нс)")
points(factor(subs_count, levels=subs_count), cpu_time, col="red", pch="X")
lines(factor(subs_count, levels=subs_count), cpu_time, col="red", lty=2, lwd=2)
legend("bottomright", legend=c("Время отправки (нс)", "Время отправки CPU (нс)"), col=c("black", "red"), lty=c(1, 2), pch=c("o", "X"), ncol=1)

plot(factor(subs_count, levels=subs_count), bytes_per_second, type="o", col="black", lty=0, ylim=c(-34663976134.50162, 71288339271.84113), xlab="", ylab="")
points(factor(subs_count, levels=subs_count), bytes_per_second, col="black", pch="o")
lines(factor(subs_count, levels=subs_count), bytes_per_second, col="black", lty=1, lwd=2)
title(main="Зависимость широты пропускания от фактора", xlab="Кол-во подписчиков", ylab="Широта пропускания (байт/сек)")
text( factor(subs_count, levels=subs_count), bytes_per_second, labels=bytes_per_second, cex= 0.7, pos=3)
points(factor(subs_count, levels=subs_count), manual_bandwidth, col="red", pch="X")
lines(factor(subs_count, levels=subs_count), manual_bandwidth, col="red", lty=2, lwd=2)
text( factor(subs_count, levels=subs_count), manual_bandwidth, labels=manual_bandwidth, cex= 0.7, pos=3)
legend("bottomright", legend=c("Широта пропускания публикующего (б/с)", "Широта пропускания принимающего (б/с)"), col=c("black", "red"), lty=c(1, 2), pch=c("o", "X"), ncol=1)

Benchmark name is “PublisherFixture/ROS_BM_Publish_method” by var=subs_count where size=65536 buffer=1

#png(filename="plot.png", width = 1600, height = 900)
subs_count <- c(1, 2, 4, 8)
real_time <- c(35241.86476183732, 34846.32125337281, 29944.50241370626, 26357.95210569732)
cpu_time <- c(33241.20863759325, 32616.890693069163, 28100.971902250858, 13736.928344962123)
bytes_per_second <- c(1904870091.11708, 3823183776.5883217, 9217878181.176826, 19933719040.95071)
manual_bandwidth <- c(1594122789.7331998, 4092402725.4754357, 14011257059.91748, 3177106811.4947248)
manual_latency <- c(39326305.28582083, 22585023.41780781, 33114581.10933975, 77158951.52757393)
df <- data.frame("factor"=subs_count, "Время отправки (нс)"=real_time, "Время отправки CPU (нс)"=cpu_time, "Широта пропускания публикующего (б/с)"=bytes_per_second, "Широта пропускания принимающего (б/с)"=manual_bandwidth, "Задержка передачи (нс)"=manual_latency)
plot(factor(subs_count, levels=subs_count), real_time, type="o", col="black", lty=0, ylim=c(-6115.252423382326, 55094.04553018177), xlab="", ylab="")
points(factor(subs_count, levels=subs_count), real_time, col="black", pch="o")
lines(factor(subs_count, levels=subs_count), real_time, col="black", lty=1, lwd=2)
title(main="Зависимость задержки от фактора", xlab="Кол-во подписчиков", ylab="Задержка (нс)")
points(factor(subs_count, levels=subs_count), cpu_time, col="red", pch="X")
lines(factor(subs_count, levels=subs_count), cpu_time, col="red", lty=2, lwd=2)
legend("bottomright", legend=c("Время отправки (нс)", "Время отправки CPU (нс)"), col=c("black", "red"), lty=c(1, 2), pch=c("o", "X"), ncol=1)

plot(factor(subs_count, levels=subs_count), bytes_per_second, type="o", col="black", lty=0, ylim=c(-25469653765.91951, 46997495596.603424), xlab="", ylab="")
points(factor(subs_count, levels=subs_count), bytes_per_second, col="black", pch="o")
lines(factor(subs_count, levels=subs_count), bytes_per_second, col="black", lty=1, lwd=2)
title(main="Зависимость широты пропускания от фактора", xlab="Кол-во подписчиков", ylab="Широта пропускания (байт/сек)")
text( factor(subs_count, levels=subs_count), bytes_per_second, labels=bytes_per_second, cex= 0.7, pos=3)
points(factor(subs_count, levels=subs_count), manual_bandwidth, col="red", pch="X")
lines(factor(subs_count, levels=subs_count), manual_bandwidth, col="red", lty=2, lwd=2)
text( factor(subs_count, levels=subs_count), manual_bandwidth, labels=manual_bandwidth, cex= 0.7, pos=3)
legend("bottomright", legend=c("Широта пропускания публикующего (б/с)", "Широта пропускания принимающего (б/с)"), col=c("black", "red"), lty=c(1, 2), pch=c("o", "X"), ncol=1)

Benchmark name is “PublisherFixture/ROS_BM_Publish_method” by var=subs_count where size=65536 buffer=10

#png(filename="plot.png", width = 1600, height = 900)
subs_count <- c(1, 2, 4, 8)
real_time <- c(32294.890055415395, 17500.153627816115, 27571.602306367615, 35193.897385136064)
cpu_time <- c(30496.115490451182, 16762.5256312205, 25937.902090064883, 25703.564367585266)
bytes_per_second <- c(2159542493.6796823, 7706105140.572764, 10078705939.816374, 15318412942.194447)
manual_bandwidth <- c(809782798.6633061, 1003249693.6337998, 5530105923.034509, 11175450356.203901)
manual_latency <- c(51469032.88383031, 64216843.20106669, 42154147.876311064, 53135941.73016544)
df <- data.frame("factor"=subs_count, "Время отправки (нс)"=real_time, "Время отправки CPU (нс)"=cpu_time, "Широта пропускания публикующего (б/с)"=bytes_per_second, "Широта пропускания принимающего (б/с)"=manual_bandwidth, "Задержка передачи (нс)"=manual_latency)
plot(factor(subs_count, levels=subs_count), real_time, type="o", col="black", lty=0, ylim=c(-5581.996788689799, 57538.41980504636), xlab="", ylab="")
points(factor(subs_count, levels=subs_count), real_time, col="black", pch="o")
lines(factor(subs_count, levels=subs_count), real_time, col="black", lty=1, lwd=2)
title(main="Зависимость задержки от фактора", xlab="Кол-во подписчиков", ylab="Задержка (нс)")
points(factor(subs_count, levels=subs_count), cpu_time, col="red", pch="X")
lines(factor(subs_count, levels=subs_count), cpu_time, col="red", lty=2, lwd=2)
legend("bottomright", legend=c("Время отправки (нс)", "Время отправки CPU (нс)"), col=c("black", "red"), lty=c(1, 2), pch=c("o", "X"), ncol=1)

plot(factor(subs_count, levels=subs_count), bytes_per_second, type="o", col="black", lty=0, ylim=c(-20910675787.916245, 37038871528.774), xlab="", ylab="")
points(factor(subs_count, levels=subs_count), bytes_per_second, col="black", pch="o")
lines(factor(subs_count, levels=subs_count), bytes_per_second, col="black", lty=1, lwd=2)
title(main="Зависимость широты пропускания от фактора", xlab="Кол-во подписчиков", ylab="Широта пропускания (байт/сек)")
text( factor(subs_count, levels=subs_count), bytes_per_second, labels=bytes_per_second, cex= 0.7, pos=3)
points(factor(subs_count, levels=subs_count), manual_bandwidth, col="red", pch="X")
lines(factor(subs_count, levels=subs_count), manual_bandwidth, col="red", lty=2, lwd=2)
text( factor(subs_count, levels=subs_count), manual_bandwidth, labels=manual_bandwidth, cex= 0.7, pos=3)
legend("bottomright", legend=c("Широта пропускания публикующего (б/с)", "Широта пропускания принимающего (б/с)"), col=c("black", "red"), lty=c(1, 2), pch=c("o", "X"), ncol=1)

Benchmark name is “PublisherFixture/ROS_BM_Publish_method” by var=subs_count where size=65536 buffer=100

#png(filename="plot.png", width = 1600, height = 900)
subs_count <- c(1, 2, 4, 8)
real_time <- c(27581.031056461135, 28008.43602805565, 34644.16481699764, 32024.28410567216)
cpu_time <- c(25898.2559040687, 26223.890796388507, 32319.58201020346, 22425.825988437267)
bytes_per_second <- c(2410643142.9612517, 5101436170.133032, 7833252639.021375, 17007940188.724356)
manual_bandwidth <- c(939146864.5975126, 7171677046.238512, 9560131902.1992, 6678025224.872855)
manual_latency <- c(60921372.31911387, 35890701.40487538, 19961973.998794958, 63351209.15346719)
df <- data.frame("factor"=subs_count, "Время отправки (нс)"=real_time, "Время отправки CPU (нс)"=cpu_time, "Широта пропускания публикующего (б/с)"=bytes_per_second, "Широта пропускания принимающего (б/с)"=manual_bandwidth, "Задержка передачи (нс)"=manual_latency)
plot(factor(subs_count, levels=subs_count), real_time, type="o", col="black", lty=0, ylim=c(2042.6904434661374, 55027.300361968766), xlab="", ylab="")
points(factor(subs_count, levels=subs_count), real_time, col="black", pch="o")
lines(factor(subs_count, levels=subs_count), real_time, col="black", lty=1, lwd=2)
title(main="Зависимость задержки от фактора", xlab="Кол-во подписчиков", ylab="Задержка (нс)")
points(factor(subs_count, levels=subs_count), cpu_time, col="red", pch="X")
lines(factor(subs_count, levels=subs_count), cpu_time, col="red", lty=2, lwd=2)
legend("bottomright", legend=c("Время отправки (нс)", "Время отправки CPU (нс)"), col=c("black", "red"), lty=c(1, 2), pch=c("o", "X"), ncol=1)

plot(factor(subs_count, levels=subs_count), bytes_per_second, type="o", col="black", lty=0, ylim=c(-16463316661.759836, 34410403715.0817), xlab="", ylab="")
points(factor(subs_count, levels=subs_count), bytes_per_second, col="black", pch="o")
lines(factor(subs_count, levels=subs_count), bytes_per_second, col="black", lty=1, lwd=2)
title(main="Зависимость широты пропускания от фактора", xlab="Кол-во подписчиков", ylab="Широта пропускания (байт/сек)")
text( factor(subs_count, levels=subs_count), bytes_per_second, labels=bytes_per_second, cex= 0.7, pos=3)
points(factor(subs_count, levels=subs_count), manual_bandwidth, col="red", pch="X")
lines(factor(subs_count, levels=subs_count), manual_bandwidth, col="red", lty=2, lwd=2)
text( factor(subs_count, levels=subs_count), manual_bandwidth, labels=manual_bandwidth, cex= 0.7, pos=3)
legend("bottomright", legend=c("Широта пропускания публикующего (б/с)", "Широта пропускания принимающего (б/с)"), col=c("black", "red"), lty=c(1, 2), pch=c("o", "X"), ncol=1)

Benchmark name is “PublisherFixture/ROS_BM_Publish_method” by var=subs_count where size=65536 buffer=1000

#png(filename="plot.png", width = 1600, height = 900)
subs_count <- c(1, 2, 4, 8)
real_time <- c(32410.539184549638, 42374.0165652213, 36526.00896665214, 37114.691981497155)
cpu_time <- c(30571.879910891334, 39491.78780987342, 34106.24228974003, 31354.976325669682)
bytes_per_second <- c(2039646241.2514234, 3146917715.8547606, 7254261781.212016, 14200083765.948536)
manual_bandwidth <- c(1267576171.691979, 6653376706.351194, 11418274712.35957, 12147668777.79102)
manual_latency <- c(45286113.04486585, 9491419.226514764, 16673952.391487712, 24121523.844174843)
df <- data.frame("factor"=subs_count, "Время отправки (нс)"=real_time, "Время отправки CPU (нс)"=cpu_time, "Широта пропускания публикующего (б/с)"=bytes_per_second, "Широта пропускания принимающего (б/с)"=manual_bandwidth, "Задержка передачи (нс)"=manual_latency)
plot(factor(subs_count, levels=subs_count), real_time, type="o", col="black", lty=0, ylim=c(16142.913827913348, 56802.98264819929), xlab="", ylab="")
points(factor(subs_count, levels=subs_count), real_time, col="black", pch="o")
lines(factor(subs_count, levels=subs_count), real_time, col="black", lty=1, lwd=2)
title(main="Зависимость задержки от фактора", xlab="Кол-во подписчиков", ylab="Задержка (нс)")
points(factor(subs_count, levels=subs_count), cpu_time, col="red", pch="X")
lines(factor(subs_count, levels=subs_count), cpu_time, col="red", lty=2, lwd=2)
legend("bottomright", legend=c("Время отправки (нс)", "Время отправки CPU (нс)"), col=c("black", "red"), lty=c(1, 2), pch=c("o", "X"), ncol=1)

plot(factor(subs_count, levels=subs_count), bytes_per_second, type="o", col="black", lty=0, ylim=c(-13533265924.79878, 29000925862.439293), xlab="", ylab="")
points(factor(subs_count, levels=subs_count), bytes_per_second, col="black", pch="o")
lines(factor(subs_count, levels=subs_count), bytes_per_second, col="black", lty=1, lwd=2)
title(main="Зависимость широты пропускания от фактора", xlab="Кол-во подписчиков", ylab="Широта пропускания (байт/сек)")
text( factor(subs_count, levels=subs_count), bytes_per_second, labels=bytes_per_second, cex= 0.7, pos=3)
points(factor(subs_count, levels=subs_count), manual_bandwidth, col="red", pch="X")
lines(factor(subs_count, levels=subs_count), manual_bandwidth, col="red", lty=2, lwd=2)
text( factor(subs_count, levels=subs_count), manual_bandwidth, labels=manual_bandwidth, cex= 0.7, pos=3)
legend("bottomright", legend=c("Широта пропускания публикующего (б/с)", "Широта пропускания принимающего (б/с)"), col=c("black", "red"), lty=c(1, 2), pch=c("o", "X"), ncol=1)

Benchmark name is “PublisherFixture/ROS_BM_Publish_method” by var=subs_count where size=65536 buffer=10000

#png(filename="plot.png", width = 1600, height = 900)
subs_count <- c(1, 2, 4, 8)
real_time <- c(30851.068553369067, 28791.789275937354, 27265.91673362119, 26744.575728683914)
cpu_time <- c(29106.578206122278, 27099.29849543299, 25648.98542756456, 13767.792037115656)
bytes_per_second <- c(2187382139.450816, 4673009781.780072, 10482922214.487345, 19674436567.124065)
manual_bandwidth <- c(1099325007.183746, 4783599694.026499, 7309314599.778905, 2955778345.460847)
manual_latency <- c(46460204.54936122, 33457553.783326417, 37669459.2848752, 82449028.50482565)
df <- data.frame("factor"=subs_count, "Время отправки (нс)"=real_time, "Время отправки CPU (нс)"=cpu_time, "Широта пропускания публикующего (б/с)"=bytes_per_second, "Широта пропускания принимающего (б/с)"=manual_bandwidth, "Задержка передачи (нс)"=manual_latency)
plot(factor(subs_count, levels=subs_count), real_time, type="o", col="black", lty=0, ylim=c(-6152.304670020806, 50771.16526050553), xlab="", ylab="")
points(factor(subs_count, levels=subs_count), real_time, col="black", pch="o")
lines(factor(subs_count, levels=subs_count), real_time, col="black", lty=1, lwd=2)
title(main="Зависимость задержки от фактора", xlab="Кол-во подписчиков", ylab="Задержка (нс)")
points(factor(subs_count, levels=subs_count), cpu_time, col="red", pch="X")
lines(factor(subs_count, levels=subs_count), cpu_time, col="red", lty=2, lwd=2)
legend("bottomright", legend=c("Время отправки (нс)", "Время отправки CPU (нс)"), col=c("black", "red"), lty=c(1, 2), pch=c("o", "X"), ncol=1)

plot(factor(subs_count, levels=subs_count), bytes_per_second, type="o", col="black", lty=0, ylim=c(-19233141508.742195, 40006903083.05001), xlab="", ylab="")
points(factor(subs_count, levels=subs_count), bytes_per_second, col="black", pch="o")
lines(factor(subs_count, levels=subs_count), bytes_per_second, col="black", lty=1, lwd=2)
title(main="Зависимость широты пропускания от фактора", xlab="Кол-во подписчиков", ylab="Широта пропускания (байт/сек)")
text( factor(subs_count, levels=subs_count), bytes_per_second, labels=bytes_per_second, cex= 0.7, pos=3)
points(factor(subs_count, levels=subs_count), manual_bandwidth, col="red", pch="X")
lines(factor(subs_count, levels=subs_count), manual_bandwidth, col="red", lty=2, lwd=2)
text( factor(subs_count, levels=subs_count), manual_bandwidth, labels=manual_bandwidth, cex= 0.7, pos=3)
legend("bottomright", legend=c("Широта пропускания публикующего (б/с)", "Широта пропускания принимающего (б/с)"), col=c("black", "red"), lty=c(1, 2), pch=c("o", "X"), ncol=1)

Benchmark name is “PublisherFixture/ROS_BM_Publish_method” by var=subs_count where size=262144 buffer=1

#png(filename="plot.png", width = 1600, height = 900)
subs_count <- c(1, 2, 4, 8)
real_time <- c(114268.43880865749, 138466.80334453724, 86679.54204052503, 109822.98327717185)
cpu_time <- c(108479.34467634936, 129852.51859758081, 82794.52101032724, 68027.28275471374)
bytes_per_second <- c(2323881701.4534497, 3929260681.2738633, 12849323610.198, 23491295832.524227)
manual_bandwidth <- c(561893310.21282, 1104191718.8160434, 2259050407.348436, 3779829285.59348)
manual_latency <- c(76813681.20076752, 80577364.41085295, 86140909.76873703, 118490523.2363313)
df <- data.frame("factor"=subs_count, "Время отправки (нс)"=real_time, "Время отправки CPU (нс)"=cpu_time, "Широта пропускания публикующего (б/с)"=bytes_per_second, "Широта пропускания принимающего (б/с)"=manual_bandwidth, "Задержка передачи (нс)"=manual_latency)
plot(factor(subs_count, levels=subs_count), real_time, type="o", col="black", lty=0, ylim=c(-51742.81142369344, 258236.89752294443), xlab="", ylab="")
points(factor(subs_count, levels=subs_count), real_time, col="black", pch="o")
lines(factor(subs_count, levels=subs_count), real_time, col="black", lty=1, lwd=2)
title(main="Зависимость задержки от фактора", xlab="Кол-во подписчиков", ylab="Задержка (нс)")
points(factor(subs_count, levels=subs_count), cpu_time, col="red", pch="X")
lines(factor(subs_count, levels=subs_count), cpu_time, col="red", lty=2, lwd=2)
legend("bottomright", legend=c("Время отправки (нс)", "Время отправки CPU (нс)"), col=c("black", "red"), lty=c(1, 2), pch=c("o", "X"), ncol=1)

plot(factor(subs_count, levels=subs_count), bytes_per_second, type="o", col="black", lty=0, ylim=c(-24921388681.438683, 48974577824.17573), xlab="", ylab="")
points(factor(subs_count, levels=subs_count), bytes_per_second, col="black", pch="o")
lines(factor(subs_count, levels=subs_count), bytes_per_second, col="black", lty=1, lwd=2)
title(main="Зависимость широты пропускания от фактора", xlab="Кол-во подписчиков", ylab="Широта пропускания (байт/сек)")
text( factor(subs_count, levels=subs_count), bytes_per_second, labels=bytes_per_second, cex= 0.7, pos=3)
points(factor(subs_count, levels=subs_count), manual_bandwidth, col="red", pch="X")
lines(factor(subs_count, levels=subs_count), manual_bandwidth, col="red", lty=2, lwd=2)
text( factor(subs_count, levels=subs_count), manual_bandwidth, labels=manual_bandwidth, cex= 0.7, pos=3)
legend("bottomright", legend=c("Широта пропускания публикующего (б/с)", "Широта пропускания принимающего (б/с)"), col=c("black", "red"), lty=c(1, 2), pch=c("o", "X"), ncol=1)

Benchmark name is “PublisherFixture/ROS_BM_Publish_method” by var=subs_count where size=262144 buffer=10

#png(filename="plot.png", width = 1600, height = 900)
subs_count <- c(1, 2, 4, 8)
real_time <- c(93697.43355981298, 156678.52654583377, 210490.30252709132, 110800.22258164443)
cpu_time <- c(89347.84447660146, 146432.22351725868, 193232.61614858796, 68091.55215840395)
bytes_per_second <- c(2926476322.412967, 3377772643.1434693, 5124425685.3186455, 24476482502.333714)
manual_bandwidth <- c(489084389.21603614, 3473434842.778556, 3275857905.639853, 2794785200.495612)
manual_latency <- c(77811452.96430251, 73459386.45098288, 41921718.62008665, 119467162.81183815)
df <- data.frame("factor"=subs_count, "Время отправки (нс)"=real_time, "Время отправки CPU (нс)"=cpu_time, "Широта пропускания публикующего (б/с)"=bytes_per_second, "Широта пропускания принимающего (б/с)"=manual_bandwidth, "Задержка передачи (нс)"=manual_latency)
plot(factor(subs_count, levels=subs_count), real_time, type="o", col="black", lty=0, ylim=c(-101420.10967365727, 380001.96435915254), xlab="", ylab="")
points(factor(subs_count, levels=subs_count), real_time, col="black", pch="o")
lines(factor(subs_count, levels=subs_count), real_time, col="black", lty=1, lwd=2)
title(main="Зависимость задержки от фактора", xlab="Кол-во подписчиков", ylab="Задержка (нс)")
points(factor(subs_count, levels=subs_count), cpu_time, col="red", pch="X")
lines(factor(subs_count, levels=subs_count), cpu_time, col="red", lty=2, lwd=2)
legend("bottomright", legend=c("Время отправки (нс)", "Время отправки CPU (нс)"), col=c("black", "red"), lty=c(1, 2), pch=c("o", "X"), ncol=1)

plot(factor(subs_count, levels=subs_count), bytes_per_second, type="o", col="black", lty=0, ylim=c(-26348594081.5325, 51314160973.082245), xlab="", ylab="")
points(factor(subs_count, levels=subs_count), bytes_per_second, col="black", pch="o")
lines(factor(subs_count, levels=subs_count), bytes_per_second, col="black", lty=1, lwd=2)
title(main="Зависимость широты пропускания от фактора", xlab="Кол-во подписчиков", ylab="Широта пропускания (байт/сек)")
text( factor(subs_count, levels=subs_count), bytes_per_second, labels=bytes_per_second, cex= 0.7, pos=3)
points(factor(subs_count, levels=subs_count), manual_bandwidth, col="red", pch="X")
lines(factor(subs_count, levels=subs_count), manual_bandwidth, col="red", lty=2, lwd=2)
text( factor(subs_count, levels=subs_count), manual_bandwidth, labels=manual_bandwidth, cex= 0.7, pos=3)
legend("bottomright", legend=c("Широта пропускания публикующего (б/с)", "Широта пропускания принимающего (б/с)"), col=c("black", "red"), lty=c(1, 2), pch=c("o", "X"), ncol=1)

Benchmark name is “PublisherFixture/ROS_BM_Publish_method” by var=subs_count where size=262144 buffer=100

#png(filename="plot.png", width = 1600, height = 900)
subs_count <- c(1, 2, 4, 8)
real_time <- c(115074.4071538304, 118446.11124035002, 134070.25446016068, 260218.0751775884)
cpu_time <- c(109212.65418650089, 112039.72276923378, 124878.06475391709, 125199.27996564968)
bytes_per_second <- c(2285440169.120406, 4632655800.211837, 9851014823.972012, 8093676400.117966)
manual_bandwidth <- c(660527389.5495522, 1893473696.7061825, 5994457919.501843, 1879229365.4653416)
manual_latency <- c(68887668.59135279, 83045250.55993205, 71624033.75718684, 122014240.95323467)
df <- data.frame("factor"=subs_count, "Время отправки (нс)"=real_time, "Время отправки CPU (нс)"=cpu_time, "Широта пропускания публикующего (б/с)"=bytes_per_second, "Широта пропускания принимающего (б/с)"=manual_bandwidth, "Задержка передачи (нс)"=manual_latency)
plot(factor(subs_count, levels=subs_count), real_time, type="o", col="black", lty=0, ylim=c(-61901.53230966128, 431332.2616737506), xlab="", ylab="")
points(factor(subs_count, levels=subs_count), real_time, col="black", pch="o")
lines(factor(subs_count, levels=subs_count), real_time, col="black", lty=1, lwd=2)
title(main="Зависимость задержки от фактора", xlab="Кол-во подписчиков", ylab="Задержка (нс)")
points(factor(subs_count, levels=subs_count), cpu_time, col="red", pch="X")
lines(factor(subs_count, levels=subs_count), cpu_time, col="red", lty=2, lwd=2)
legend("bottomright", legend=c("Время отправки (нс)", "Время отправки CPU (нс)"), col=c("black", "red"), lty=c(1, 2), pch=c("o", "X"), ncol=1)

plot(factor(subs_count, levels=subs_count), bytes_per_second, type="o", col="black", lty=0, ylim=c(-11780630719.705475, 22292172933.22704), xlab="", ylab="")
points(factor(subs_count, levels=subs_count), bytes_per_second, col="black", pch="o")
lines(factor(subs_count, levels=subs_count), bytes_per_second, col="black", lty=1, lwd=2)
title(main="Зависимость широты пропускания от фактора", xlab="Кол-во подписчиков", ylab="Широта пропускания (байт/сек)")
text( factor(subs_count, levels=subs_count), bytes_per_second, labels=bytes_per_second, cex= 0.7, pos=3)
points(factor(subs_count, levels=subs_count), manual_bandwidth, col="red", pch="X")
lines(factor(subs_count, levels=subs_count), manual_bandwidth, col="red", lty=2, lwd=2)
text( factor(subs_count, levels=subs_count), manual_bandwidth, labels=manual_bandwidth, cex= 0.7, pos=3)
legend("bottomright", legend=c("Широта пропускания публикующего (б/с)", "Широта пропускания принимающего (б/с)"), col=c("black", "red"), lty=c(1, 2), pch=c("o", "X"), ncol=1)

Benchmark name is “PublisherFixture/ROS_BM_Publish_method” by var=subs_count where size=262144 buffer=1000

#png(filename="plot.png", width = 1600, height = 900)
subs_count <- c(1, 2, 4, 8)
real_time <- c(83764.88011132626, 116784.93429238015, 167898.01963332348, 243600.95310142808)
cpu_time <- c(80272.52386504423, 110091.70791835929, 155198.68818133732, 139800.24062381597)
bytes_per_second <- c(3139900191.558425, 6262394445.192435, 6435647074.575093, 8800792829.299368)
manual_bandwidth <- c(692023701.5569701, 2105065632.068996, 3571684890.2738266, 3328394580.4994574)
manual_latency <- c(78444876.04642949, 69250492.06501743, 74279493.43260616, 98086085.8001049)
df <- data.frame("factor"=subs_count, "Время отправки (нс)"=real_time, "Время отправки CPU (нс)"=cpu_time, "Широта пропускания публикующего (б/с)"=bytes_per_second, "Широта пропускания принимающего (б/с)"=manual_bandwidth, "Задержка передачи (нс)"=manual_latency)
plot(factor(subs_count, levels=subs_count), real_time, type="o", col="black", lty=0, ylim=c(-101917.21329576647, 425790.6902622387), xlab="", ylab="")
points(factor(subs_count, levels=subs_count), real_time, col="black", pch="o")
lines(factor(subs_count, levels=subs_count), real_time, col="black", lty=1, lwd=2)
title(main="Зависимость задержки от фактора", xlab="Кол-во подписчиков", ylab="Задержка (нс)")
points(factor(subs_count, levels=subs_count), cpu_time, col="red", pch="X")
lines(factor(subs_count, levels=subs_count), cpu_time, col="red", lty=2, lwd=2)
legend("bottomright", legend=c("Время отправки (нс)", "Время отправки CPU (нс)"), col=c("black", "red"), lty=c(1, 2), pch=c("o", "X"), ncol=1)

plot(factor(subs_count, levels=subs_count), bytes_per_second, type="o", col="black", lty=0, ylim=c(-8269420398.139001, 17762236928.99534), xlab="", ylab="")
points(factor(subs_count, levels=subs_count), bytes_per_second, col="black", pch="o")
lines(factor(subs_count, levels=subs_count), bytes_per_second, col="black", lty=1, lwd=2)
title(main="Зависимость широты пропускания от фактора", xlab="Кол-во подписчиков", ylab="Широта пропускания (байт/сек)")
text( factor(subs_count, levels=subs_count), bytes_per_second, labels=bytes_per_second, cex= 0.7, pos=3)
points(factor(subs_count, levels=subs_count), manual_bandwidth, col="red", pch="X")
lines(factor(subs_count, levels=subs_count), manual_bandwidth, col="red", lty=2, lwd=2)
text( factor(subs_count, levels=subs_count), manual_bandwidth, labels=manual_bandwidth, cex= 0.7, pos=3)
legend("bottomright", legend=c("Широта пропускания публикующего (б/с)", "Широта пропускания принимающего (б/с)"), col=c("black", "red"), lty=c(1, 2), pch=c("o", "X"), ncol=1)

Benchmark name is “PublisherFixture/ROS_BM_Publish_method” by var=subs_count where size=262144 buffer=10000

#png(filename="plot.png", width = 1600, height = 900)
subs_count <- c(1, 2, 4, 8)
real_time <- c(100852.87849219091, 118492.05242499604, 149781.32933947368, 76824.64563602976)
cpu_time <- c(96188.6194666941, 110418.11147389459, 138081.84668269302, 51768.185009942725)
bytes_per_second <- c(2675212009.490981, 5106005358.142822, 8588301194.865343, 29977588014.06074)
manual_bandwidth <- c(629218457.0725011, 1237491098.9358497, 1755849440.5081794, 1411382350.8212028)
manual_latency <- c(77162712.9916431, 77199931.33760805, 75645148.86241046, 113611207.19254439)
df <- data.frame("factor"=subs_count, "Время отправки (нс)"=real_time, "Время отправки CPU (нс)"=cpu_time, "Широта пропускания публикующего (б/с)"=bytes_per_second, "Широта пропускания принимающего (б/с)"=manual_bandwidth, "Задержка передачи (нс)"=manual_latency)
plot(factor(subs_count, levels=subs_count), real_time, type="o", col="black", lty=0, ylim=c(-80093.4504861591, 281642.96483557555), xlab="", ylab="")
points(factor(subs_count, levels=subs_count), real_time, col="black", pch="o")
lines(factor(subs_count, levels=subs_count), real_time, col="black", lty=1, lwd=2)
title(main="Зависимость задержки от фактора", xlab="Кол-во подписчиков", ylab="Задержка (нс)")
points(factor(subs_count, levels=subs_count), cpu_time, col="red", pch="X")
lines(factor(subs_count, levels=subs_count), cpu_time, col="red", lty=2, lwd=2)
legend("bottomright", legend=c("Время отправки (нс)", "Время отправки CPU (нс)"), col=c("black", "red"), lty=c(1, 2), pch=c("o", "X"), ncol=1)

plot(factor(subs_count, levels=subs_count), bytes_per_second, type="o", col="black", lty=0, ylim=c(-23866401849.242867, 54473208320.376114), xlab="", ylab="")
points(factor(subs_count, levels=subs_count), bytes_per_second, col="black", pch="o")
lines(factor(subs_count, levels=subs_count), bytes_per_second, col="black", lty=1, lwd=2)
title(main="Зависимость широты пропускания от фактора", xlab="Кол-во подписчиков", ylab="Широта пропускания (байт/сек)")
text( factor(subs_count, levels=subs_count), bytes_per_second, labels=bytes_per_second, cex= 0.7, pos=3)
points(factor(subs_count, levels=subs_count), manual_bandwidth, col="red", pch="X")
lines(factor(subs_count, levels=subs_count), manual_bandwidth, col="red", lty=2, lwd=2)
text( factor(subs_count, levels=subs_count), manual_bandwidth, labels=manual_bandwidth, cex= 0.7, pos=3)
legend("bottomright", legend=c("Широта пропускания публикующего (б/с)", "Широта пропускания принимающего (б/с)"), col=c("black", "red"), lty=c(1, 2), pch=c("o", "X"), ncol=1)

Benchmark name is “PublisherFixture/ROS_BM_Publish_method” by var=subs_count where size=1048576 buffer=1

#png(filename="plot.png", width = 1600, height = 900)
subs_count <- c(1, 2, 4, 8)
real_time <- c(1045110.7708889504, 1049393.0118269408, 1019453.1587962955, 510811.6901620716)
cpu_time <- c(1006048.5644091123, 998608.2619041704, 946961.6993996624, 348529.2104119652)
bytes_per_second <- c(1003449314.9936724, 1999232016.0359528, 4126594766.9789224, 21468127100.79583)
manual_bandwidth <- c(105805925.1746181, 297587554.9579857, 1611068316.3186483, 2698813036.744806)
manual_latency <- c(137343184.1157684, 101937629.46190262, 82817313.55019698, 175578147.78588906)
df <- data.frame("factor"=subs_count, "Время отправки (нс)"=real_time, "Время отправки CPU (нс)"=cpu_time, "Широта пропускания публикующего (б/с)"=bytes_per_second, "Широта пропускания принимающего (б/с)"=manual_bandwidth, "Задержка передачи (нс)"=manual_latency)
plot(factor(subs_count, levels=subs_count), real_time, type="o", col="black", lty=0, ylim=c(-408752.6276114963, 1806674.8498504022), xlab="", ylab="")
points(factor(subs_count, levels=subs_count), real_time, col="black", pch="o")
lines(factor(subs_count, levels=subs_count), real_time, col="black", lty=1, lwd=2)
title(main="Зависимость задержки от фактора", xlab="Кол-во подписчиков", ylab="Задержка (нс)")
points(factor(subs_count, levels=subs_count), cpu_time, col="red", pch="X")
lines(factor(subs_count, levels=subs_count), cpu_time, col="red", lty=2, lwd=2)
legend("bottomright", legend=c("Время отправки (нс)", "Время отправки CPU (нс)"), col=c("black", "red"), lty=c(1, 2), pch=c("o", "X"), ncol=1)

plot(factor(subs_count, levels=subs_count), bytes_per_second, type="o", col="black", lty=0, ylim=c(-25273487023.36264, 46847420049.333084), xlab="", ylab="")
points(factor(subs_count, levels=subs_count), bytes_per_second, col="black", pch="o")
lines(factor(subs_count, levels=subs_count), bytes_per_second, col="black", lty=1, lwd=2)
title(main="Зависимость широты пропускания от фактора", xlab="Кол-во подписчиков", ylab="Широта пропускания (байт/сек)")
text( factor(subs_count, levels=subs_count), bytes_per_second, labels=bytes_per_second, cex= 0.7, pos=3)
points(factor(subs_count, levels=subs_count), manual_bandwidth, col="red", pch="X")
lines(factor(subs_count, levels=subs_count), manual_bandwidth, col="red", lty=2, lwd=2)
text( factor(subs_count, levels=subs_count), manual_bandwidth, labels=manual_bandwidth, cex= 0.7, pos=3)
legend("bottomright", legend=c("Широта пропускания публикующего (б/с)", "Широта пропускания принимающего (б/с)"), col=c("black", "red"), lty=c(1, 2), pch=c("o", "X"), ncol=1)

Benchmark name is “PublisherFixture/ROS_BM_Publish_method” by var=subs_count where size=1048576 buffer=10

#png(filename="plot.png", width = 1600, height = 900)
subs_count <- c(1, 2, 4, 8)
real_time <- c(1043938.4474867955, 1062913.473846598, 1053547.9085778226, 762440.1167911757)
cpu_time <- c(1009134.8073967369, 1008077.2297174223, 983041.5359255284, 510935.05517043284)
bytes_per_second <- c(1004721114.4900757, 1973262041.9217057, 3982054647.796869, 11853508247.476137)
manual_bandwidth <- c(71085398.25787535, 315903457.72692543, 903666628.6355705, 1940537714.0710998)
manual_latency <- c(152659687.22916666, 102703338.59898433, 90803610.58428074, 135640486.32835308)
df <- data.frame("factor"=subs_count, "Время отправки (нс)"=real_time, "Время отправки CPU (нс)"=cpu_time, "Широта пропускания публикующего (б/с)"=bytes_per_second, "Широта пропускания принимающего (б/с)"=manual_bandwidth, "Задержка передачи (нс)"=manual_latency)
plot(factor(subs_count, levels=subs_count), real_time, type="o", col="black", lty=0, ylim=c(-80174.66581445915, 1654023.19483149), xlab="", ylab="")
points(factor(subs_count, levels=subs_count), real_time, col="black", pch="o")
lines(factor(subs_count, levels=subs_count), real_time, col="black", lty=1, lwd=2)
title(main="Зависимость задержки от фактора", xlab="Кол-во подписчиков", ylab="Задержка (нс)")
points(factor(subs_count, levels=subs_count), cpu_time, col="red", pch="X")
lines(factor(subs_count, levels=subs_count), cpu_time, col="red", lty=2, lwd=2)
legend("bottomright", legend=c("Время отправки (нс)", "Время отправки CPU (нс)"), col=c("black", "red"), lty=c(1, 2), pch=c("o", "X"), ncol=1)

plot(factor(subs_count, levels=subs_count), bytes_per_second, type="o", col="black", lty=0, ylim=c(-10658010301.12837, 22582603946.86238), xlab="", ylab="")
points(factor(subs_count, levels=subs_count), bytes_per_second, col="black", pch="o")
lines(factor(subs_count, levels=subs_count), bytes_per_second, col="black", lty=1, lwd=2)
title(main="Зависимость широты пропускания от фактора", xlab="Кол-во подписчиков", ylab="Широта пропускания (байт/сек)")
text( factor(subs_count, levels=subs_count), bytes_per_second, labels=bytes_per_second, cex= 0.7, pos=3)
points(factor(subs_count, levels=subs_count), manual_bandwidth, col="red", pch="X")
lines(factor(subs_count, levels=subs_count), manual_bandwidth, col="red", lty=2, lwd=2)
text( factor(subs_count, levels=subs_count), manual_bandwidth, labels=manual_bandwidth, cex= 0.7, pos=3)
legend("bottomright", legend=c("Широта пропускания публикующего (б/с)", "Широта пропускания принимающего (б/с)"), col=c("black", "red"), lty=c(1, 2), pch=c("o", "X"), ncol=1)

Benchmark name is “PublisherFixture/ROS_BM_Publish_method” by var=subs_count where size=1048576 buffer=100

#png(filename="plot.png", width = 1600, height = 900)
subs_count <- c(1, 2, 4, 8)
real_time <- c(1051105.2499288847, 1045177.2451610618, 1008150.0168363571, 911047.9387184575)
cpu_time <- c(1004895.4915821294, 977938.2818736115, 946257.5054398484, 528270.1555309125)
bytes_per_second <- c(997716470.024121, 2008952571.5023131, 4191437308.220475, 10127067200.823347)
manual_bandwidth <- c(90615069.17813474, 404496438.7546527, 1090334610.9008038, 994764779.880153)
manual_latency <- c(125700754.313254, 88118620.99615079, 91138186.48844936, 153970209.6454524)
df <- data.frame("factor"=subs_count, "Время отправки (нс)"=real_time, "Время отправки CPU (нс)"=cpu_time, "Широта пропускания публикующего (б/с)"=bytes_per_second, "Широта пропускания принимающего (б/с)"=manual_bandwidth, "Задержка передачи (нс)"=manual_latency)
plot(factor(subs_count, levels=subs_count), real_time, type="o", col="black", lty=0, ylim=c(-107273.62653042475, 1686649.0319902217), xlab="", ylab="")
points(factor(subs_count, levels=subs_count), real_time, col="black", pch="o")
lines(factor(subs_count, levels=subs_count), real_time, col="black", lty=1, lwd=2)
title(main="Зависимость задержки от фактора", xlab="Кол-во подписчиков", ylab="Задержка (нс)")
points(factor(subs_count, levels=subs_count), cpu_time, col="red", pch="X")
lines(factor(subs_count, levels=subs_count), cpu_time, col="red", lty=2, lwd=2)
legend("bottomright", legend=c("Время отправки (нс)", "Время отправки CPU (нс)"), col=c("black", "red"), lty=c(1, 2), pch=c("o", "X"), ncol=1)

plot(factor(subs_count, levels=subs_count), bytes_per_second, type="o", col="black", lty=0, ylim=c(-10103196253.030308, 20320878523.03179), xlab="", ylab="")
points(factor(subs_count, levels=subs_count), bytes_per_second, col="black", pch="o")
lines(factor(subs_count, levels=subs_count), bytes_per_second, col="black", lty=1, lwd=2)
title(main="Зависимость широты пропускания от фактора", xlab="Кол-во подписчиков", ylab="Широта пропускания (байт/сек)")
text( factor(subs_count, levels=subs_count), bytes_per_second, labels=bytes_per_second, cex= 0.7, pos=3)
points(factor(subs_count, levels=subs_count), manual_bandwidth, col="red", pch="X")
lines(factor(subs_count, levels=subs_count), manual_bandwidth, col="red", lty=2, lwd=2)
text( factor(subs_count, levels=subs_count), manual_bandwidth, labels=manual_bandwidth, cex= 0.7, pos=3)
legend("bottomright", legend=c("Широта пропускания публикующего (б/с)", "Широта пропускания принимающего (б/с)"), col=c("black", "red"), lty=c(1, 2), pch=c("o", "X"), ncol=1)

Benchmark name is “PublisherFixture/ROS_BM_Publish_method” by var=subs_count where size=1048576 buffer=1000

#png(filename="plot.png", width = 1600, height = 900)
subs_count <- c(1, 2, 4, 8)
real_time <- c(1044106.2189312959, 1043647.9576920314, 1065363.2333856323, 601452.4260553325)
cpu_time <- c(996014.952023052, 976763.3032344186, 1011206.7681832307, 403381.4325192258)
bytes_per_second <- c(1004412110.5288732, 2011586122.5647187, 3940250242.7986403, 19398732091.098022)
manual_bandwidth <- c(175012270.98146084, 555374458.9687614, 487172300.56533176, 1060638106.6713841)
manual_latency <- c(101784359.23296383, 82358254.74070504, 139895687.1297222, 134003672.71977839)
df <- data.frame("factor"=subs_count, "Время отправки (нс)"=real_time, "Время отправки CPU (нс)"=cpu_time, "Широта пропускания публикующего (б/с)"=bytes_per_second, "Широта пропускания принимающего (б/с)"=manual_bandwidth, "Задержка передачи (нс)"=manual_latency)
plot(factor(subs_count, levels=subs_count), real_time, type="o", col="black", lty=0, ylim=c(-425772.57515460066, 1894517.2410594588), xlab="", ylab="")
points(factor(subs_count, levels=subs_count), real_time, col="black", pch="o")
lines(factor(subs_count, levels=subs_count), real_time, col="black", lty=1, lwd=2)
title(main="Зависимость задержки от фактора", xlab="Кол-во подписчиков", ylab="Задержка (нс)")
points(factor(subs_count, levels=subs_count), cpu_time, col="red", pch="X")
lines(factor(subs_count, levels=subs_count), cpu_time, col="red", lty=2, lwd=2)
legend("bottomright", legend=c("Время отправки (нс)", "Время отправки CPU (нс)"), col=c("black", "red"), lty=c(1, 2), pch=c("o", "X"), ncol=1)

plot(factor(subs_count, levels=subs_count), bytes_per_second, type="o", col="black", lty=0, ylim=c(-25226850776.574684, 44800595138.65417), xlab="", ylab="")
points(factor(subs_count, levels=subs_count), bytes_per_second, col="black", pch="o")
lines(factor(subs_count, levels=subs_count), bytes_per_second, col="black", lty=1, lwd=2)
title(main="Зависимость широты пропускания от фактора", xlab="Кол-во подписчиков", ylab="Широта пропускания (байт/сек)")
text( factor(subs_count, levels=subs_count), bytes_per_second, labels=bytes_per_second, cex= 0.7, pos=3)
points(factor(subs_count, levels=subs_count), manual_bandwidth, col="red", pch="X")
lines(factor(subs_count, levels=subs_count), manual_bandwidth, col="red", lty=2, lwd=2)
text( factor(subs_count, levels=subs_count), manual_bandwidth, labels=manual_bandwidth, cex= 0.7, pos=3)
legend("bottomright", legend=c("Широта пропускания публикующего (б/с)", "Широта пропускания принимающего (б/с)"), col=c("black", "red"), lty=c(1, 2), pch=c("o", "X"), ncol=1)

Benchmark name is “PublisherFixture/ROS_BM_Publish_method” by var=subs_count where size=1048576 buffer=10000

#png(filename="plot.png", width = 1600, height = 900)
subs_count <- c(1, 2, 4, 8)
real_time <- c(1052824.5458658107, 1056295.8743406371, 1057543.882882535, 813896.3905363408)
cpu_time <- c(1002082.1166906192, 1001880.9252224505, 1005631.0280327635, 496177.1286857225)
bytes_per_second <- c(996056474.4295423, 1985621035.2700417, 3967768007.405999, 11799426264.071325)
manual_bandwidth <- c(142791755.3746472, 277874947.56378603, 530392484.89424354, 5200331369.972635)
manual_latency <- c(102741443.81669703, 101509351.58627497, 92438736.00555554, 147217498.16139644)
df <- data.frame("factor"=subs_count, "Время отправки (нс)"=real_time, "Время отправки CPU (нс)"=cpu_time, "Широта пропускания публикующего (б/с)"=bytes_per_second, "Широта пропускания принимающего (б/с)"=manual_bandwidth, "Задержка передачи (нс)"=manual_latency)
plot(factor(subs_count, levels=subs_count), real_time, type="o", col="black", lty=0, ylim=c(-106344.5190819116, 1660065.5306501691), xlab="", ylab="")
points(factor(subs_count, levels=subs_count), real_time, col="black", pch="o")
lines(factor(subs_count, levels=subs_count), real_time, col="black", lty=1, lwd=2)
title(main="Зависимость задержки от фактора", xlab="Кол-во подписчиков", ylab="Задержка (нс)")
points(factor(subs_count, levels=subs_count), cpu_time, col="red", pch="X")
lines(factor(subs_count, levels=subs_count), cpu_time, col="red", lty=2, lwd=2)
legend("bottomright", legend=c("Время отправки (нс)", "Время отправки CPU (нс)"), col=c("black", "red"), lty=c(1, 2), pch=c("o", "X"), ncol=1)

plot(factor(subs_count, levels=subs_count), bytes_per_second, type="o", col="black", lty=0, ylim=c(-14896804336.757967, 26839022356.20394), xlab="", ylab="")
points(factor(subs_count, levels=subs_count), bytes_per_second, col="black", pch="o")
lines(factor(subs_count, levels=subs_count), bytes_per_second, col="black", lty=1, lwd=2)
title(main="Зависимость широты пропускания от фактора", xlab="Кол-во подписчиков", ylab="Широта пропускания (байт/сек)")
text( factor(subs_count, levels=subs_count), bytes_per_second, labels=bytes_per_second, cex= 0.7, pos=3)
points(factor(subs_count, levels=subs_count), manual_bandwidth, col="red", pch="X")
lines(factor(subs_count, levels=subs_count), manual_bandwidth, col="red", lty=2, lwd=2)
text( factor(subs_count, levels=subs_count), manual_bandwidth, labels=manual_bandwidth, cex= 0.7, pos=3)
legend("bottomright", legend=c("Широта пропускания публикующего (б/с)", "Широта пропускания принимающего (б/с)"), col=c("black", "red"), lty=c(1, 2), pch=c("o", "X"), ncol=1)

Benchmark name is “PublisherFixture/ROS_BM_Publish_method” by var=subs_count where size=4194304 buffer=1

#png(filename="plot.png", width = 1600, height = 900)
subs_count <- c(1, 2, 4, 8)
real_time <- c(3753850.3210739205, 2557254.6511730812, 2207735.459279661, 1554646.5007241913)
cpu_time <- c(3713596.038016802, 2528496.416431994, 2146591.974364406, 1124270.9667290214)
bytes_per_second <- c(1217603642.0833662, 4849990870.313324, 9073821024.198309, 22719089450.150375)
manual_bandwidth <- c(16458417.004081905, 43486142.14427169, 107360186.24234459, 754037456.8582256)
manual_latency <- c(590373219.65, 596726049.9999999, 619456585.3566667, 346825505.2583333)
df <- data.frame("factor"=subs_count, "Время отправки (нс)"=real_time, "Время отправки CPU (нс)"=cpu_time, "Широта пропускания публикующего (б/с)"=bytes_per_second, "Широта пропускания принимающего (б/с)"=manual_bandwidth, "Задержка передачи (нс)"=manual_latency)
plot(factor(subs_count, levels=subs_count), real_time, type="o", col="black", lty=0, ylim=c(-2042881.4571486192, 6921002.744951561), xlab="", ylab="")
points(factor(subs_count, levels=subs_count), real_time, col="black", pch="o")
lines(factor(subs_count, levels=subs_count), real_time, col="black", lty=1, lwd=2)
title(main="Зависимость задержки от фактора", xlab="Кол-во подписчиков", ylab="Задержка (нс)")
points(factor(subs_count, levels=subs_count), cpu_time, col="red", pch="X")
lines(factor(subs_count, levels=subs_count), cpu_time, col="red", lty=2, lwd=2)
legend("bottomright", legend=c("Время отправки (нс)", "Время отправки CPU (нс)"), col=c("black", "red"), lty=c(1, 2), pch=c("o", "X"), ncol=1)

plot(factor(subs_count, levels=subs_count), bytes_per_second, type="o", col="black", lty=0, ylim=c(-18690422994.085796, 41425970861.24025), xlab="", ylab="")
points(factor(subs_count, levels=subs_count), bytes_per_second, col="black", pch="o")
lines(factor(subs_count, levels=subs_count), bytes_per_second, col="black", lty=1, lwd=2)
title(main="Зависимость широты пропускания от фактора", xlab="Кол-во подписчиков", ylab="Широта пропускания (байт/сек)")
text( factor(subs_count, levels=subs_count), bytes_per_second, labels=bytes_per_second, cex= 0.7, pos=3)
points(factor(subs_count, levels=subs_count), manual_bandwidth, col="red", pch="X")
lines(factor(subs_count, levels=subs_count), manual_bandwidth, col="red", lty=2, lwd=2)
text( factor(subs_count, levels=subs_count), manual_bandwidth, labels=manual_bandwidth, cex= 0.7, pos=3)
legend("bottomright", legend=c("Широта пропускания публикующего (б/с)", "Широта пропускания принимающего (б/с)"), col=c("black", "red"), lty=c(1, 2), pch=c("o", "X"), ncol=1)

Benchmark name is “PublisherFixture/ROS_BM_Publish_method” by var=subs_count where size=4194304 buffer=10

#png(filename="plot.png", width = 1600, height = 900)
subs_count <- c(1, 2, 4, 8)
real_time <- c(2538826.699143001, 2448094.834862402, 2015943.2467647314, 1321079.7203019361)
cpu_time <- c(2497592.8508471227, 2410404.031687948, 1980392.9275694578, 1049516.1158216244)
bytes_per_second <- c(2222609749.2521906, 4865094016.236982, 10838747136.070347, 26569579728.799263)
manual_bandwidth <- c(38100873.85264189, 51878344.542379335, 112091357.4218053, 472345704.5246213)
manual_latency <- c(407792625.5516667, 472805668.7499999, 435758229.1333333, 339775773.6261905)
df <- data.frame("factor"=subs_count, "Время отправки (нс)"=real_time, "Время отправки CPU (нс)"=cpu_time, "Широта пропускания публикующего (б/с)"=bytes_per_second, "Широта пропускания принимающего (б/с)"=manual_bandwidth, "Задержка передачи (нс)"=manual_latency)
plot(factor(subs_count, levels=subs_count), real_time, type="o", col="black", lty=0, ylim=c(-1670053.531859784, 5258396.346824409), xlab="", ylab="")
points(factor(subs_count, levels=subs_count), real_time, col="black", pch="o")
lines(factor(subs_count, levels=subs_count), real_time, col="black", lty=1, lwd=2)
title(main="Зависимость задержки от фактора", xlab="Кол-во подписчиков", ylab="Задержка (нс)")
points(factor(subs_count, levels=subs_count), cpu_time, col="red", pch="X")
lines(factor(subs_count, levels=subs_count), cpu_time, col="red", lty=2, lwd=2)
legend("bottomright", legend=c("Время отправки (нс)", "Время отправки CPU (нс)"), col=c("black", "red"), lty=c(1, 2), pch=c("o", "X"), ncol=1)

plot(factor(subs_count, levels=subs_count), bytes_per_second, type="o", col="black", lty=0, ylim=c(-21877876130.915676, 48485556733.56758), xlab="", ylab="")
points(factor(subs_count, levels=subs_count), bytes_per_second, col="black", pch="o")
lines(factor(subs_count, levels=subs_count), bytes_per_second, col="black", lty=1, lwd=2)
title(main="Зависимость широты пропускания от фактора", xlab="Кол-во подписчиков", ylab="Широта пропускания (байт/сек)")
text( factor(subs_count, levels=subs_count), bytes_per_second, labels=bytes_per_second, cex= 0.7, pos=3)
points(factor(subs_count, levels=subs_count), manual_bandwidth, col="red", pch="X")
lines(factor(subs_count, levels=subs_count), manual_bandwidth, col="red", lty=2, lwd=2)
text( factor(subs_count, levels=subs_count), manual_bandwidth, labels=manual_bandwidth, cex= 0.7, pos=3)
legend("bottomright", legend=c("Широта пропускания публикующего (б/с)", "Широта пропускания принимающего (б/с)"), col=c("black", "red"), lty=c(1, 2), pch=c("o", "X"), ncol=1)

Benchmark name is “PublisherFixture/ROS_BM_Publish_method” by var=subs_count where size=4194304 buffer=100

#png(filename="plot.png", width = 1600, height = 900)
subs_count <- c(1, 2, 4, 8)
real_time <- c(2434603.9247404262, 2315141.7616982264, 1995241.8501838427, 1115102.688853146)
cpu_time <- c(2402506.9499997115, 2273895.2883129334, 1960510.2177928023, 952194.2029372273)
bytes_per_second <- c(1876029897.5067196, 5910106222.714949, 9565382380.90919, 30131409511.12666)
manual_bandwidth <- c(49531512.28005635, 46890340.817584045, 147367059.01183873, 380410481.8633764)
manual_latency <- c(382650046.6, 342137895.0, 443972059.35999995, 456539274.82666665)
df <- data.frame("factor"=subs_count, "Время отправки (нс)"=real_time, "Время отправки CPU (нс)"=cpu_time, "Широта пропускания публикующего (б/с)"=bytes_per_second, "Широта пропускания принимающего (б/с)"=manual_bandwidth, "Задержка передачи (нс)"=manual_latency)
plot(factor(subs_count, levels=subs_count), real_time, type="o", col="black", lty=0, ylim=c(-2008771.6355992802, 5395569.763276935), xlab="", ylab="")
points(factor(subs_count, levels=subs_count), real_time, col="black", pch="o")
lines(factor(subs_count, levels=subs_count), real_time, col="black", lty=1, lwd=2)
title(main="Зависимость задержки от фактора", xlab="Кол-во подписчиков", ylab="Задержка (нс)")
points(factor(subs_count, levels=subs_count), cpu_time, col="red", pch="X")
lines(factor(subs_count, levels=subs_count), cpu_time, col="red", lty=2, lwd=2)
legend("bottomright", legend=c("Время отправки (нс)", "Время отправки CPU (нс)"), col=c("black", "red"), lty=c(1, 2), pch=c("o", "X"), ncol=1)

plot(factor(subs_count, levels=subs_count), bytes_per_second, type="o", col="black", lty=0, ylim=c(-20986523223.182995, 51164823075.127235), xlab="", ylab="")
points(factor(subs_count, levels=subs_count), bytes_per_second, col="black", pch="o")
lines(factor(subs_count, levels=subs_count), bytes_per_second, col="black", lty=1, lwd=2)
title(main="Зависимость широты пропускания от фактора", xlab="Кол-во подписчиков", ylab="Широта пропускания (байт/сек)")
text( factor(subs_count, levels=subs_count), bytes_per_second, labels=bytes_per_second, cex= 0.7, pos=3)
points(factor(subs_count, levels=subs_count), manual_bandwidth, col="red", pch="X")
lines(factor(subs_count, levels=subs_count), manual_bandwidth, col="red", lty=2, lwd=2)
text( factor(subs_count, levels=subs_count), manual_bandwidth, labels=manual_bandwidth, cex= 0.7, pos=3)
legend("bottomright", legend=c("Широта пропускания публикующего (б/с)", "Широта пропускания принимающего (б/с)"), col=c("black", "red"), lty=c(1, 2), pch=c("o", "X"), ncol=1)

Benchmark name is “PublisherFixture/ROS_BM_Publish_method” by var=subs_count where size=4194304 buffer=1000

#png(filename="plot.png", width = 1600, height = 900)
subs_count <- c(1, 2, 4, 8)
real_time <- c(3573191.76375081, 2359972.559685654, 1862110.5648453697, 1596832.6717077282)
cpu_time <- c(3540859.590603914, 2311370.5142863803, 1807315.7705451879, 1182508.6655702316)
bytes_per_second <- c(1226689567.3281274, 5012215604.68105, 11731203931.272608, 21702803410.23856)
manual_bandwidth <- c(28570435.29598547, 46795938.886254385, 180829248.2683262, 512917373.6292697)
manual_latency <- c(376512161.325, 421625248.225, 365490733.16833335, 340102879.95178574)
df <- data.frame("factor"=subs_count, "Время отправки (нс)"=real_time, "Время отправки CPU (нс)"=cpu_time, "Широта пропускания публикующего (б/с)"=bytes_per_second, "Широта пропускания принимающего (б/с)"=manual_bandwidth, "Задержка передачи (нс)"=manual_latency)
plot(factor(subs_count, levels=subs_count), real_time, type="o", col="black", lty=0, ylim=c(-1700413.1406053854, 6456113.569926427), xlab="", ylab="")
points(factor(subs_count, levels=subs_count), real_time, col="black", pch="o")
lines(factor(subs_count, levels=subs_count), real_time, col="black", lty=1, lwd=2)
title(main="Зависимость задержки от фактора", xlab="Кол-во подписчиков", ylab="Задержка (нс)")
points(factor(subs_count, levels=subs_count), cpu_time, col="red", pch="X")
lines(factor(subs_count, levels=subs_count), cpu_time, col="red", lty=2, lwd=2)
legend("bottomright", legend=c("Время отправки (нс)", "Время отправки CPU (нс)"), col=c("black", "red"), lty=c(1, 2), pch=c("o", "X"), ncol=1)

plot(factor(subs_count, levels=subs_count), bytes_per_second, type="o", col="black", lty=0, ylim=c(-18864030733.91739, 40595404579.451935), xlab="", ylab="")
points(factor(subs_count, levels=subs_count), bytes_per_second, col="black", pch="o")
lines(factor(subs_count, levels=subs_count), bytes_per_second, col="black", lty=1, lwd=2)
title(main="Зависимость широты пропускания от фактора", xlab="Кол-во подписчиков", ylab="Широта пропускания (байт/сек)")
text( factor(subs_count, levels=subs_count), bytes_per_second, labels=bytes_per_second, cex= 0.7, pos=3)
points(factor(subs_count, levels=subs_count), manual_bandwidth, col="red", pch="X")
lines(factor(subs_count, levels=subs_count), manual_bandwidth, col="red", lty=2, lwd=2)
text( factor(subs_count, levels=subs_count), manual_bandwidth, labels=manual_bandwidth, cex= 0.7, pos=3)
legend("bottomright", legend=c("Широта пропускания публикующего (б/с)", "Широта пропускания принимающего (б/с)"), col=c("black", "red"), lty=c(1, 2), pch=c("o", "X"), ncol=1)

Benchmark name is “PublisherFixture/ROS_BM_Publish_method” by var=subs_count where size=4194304 buffer=10000

#png(filename="plot.png", width = 1600, height = 900)
subs_count <- c(1, 2, 4, 8)
real_time <- c(2344889.4259120347, 2039001.39545636, 1396115.5897024714, 1350034.4842400574)
cpu_time <- c(2321858.0445348253, 2020847.947879585, 1368306.8562658033, 1125260.5958965074)
bytes_per_second <- c(2134439129.120278, 6158570988.034955, 12678530426.041998, 25328765815.109386)
manual_bandwidth <- c(43746289.07796217, 52337303.617246225, 251041516.35877603, 609886016.6254795)
manual_latency <- c(349799361.53166664, 443514995.05, 269597561.4666667, 332545706.88531744)
df <- data.frame("factor"=subs_count, "Время отправки (нс)"=real_time, "Время отправки CPU (нс)"=cpu_time, "Широта пропускания публикующего (б/с)"=bytes_per_second, "Широта пропускания принимающего (б/с)"=manual_bandwidth, "Задержка передачи (нс)"=manual_latency)
plot(factor(subs_count, levels=subs_count), real_time, type="o", col="black", lty=0, ylim=c(-1287544.8492502118, 4757694.871058754), xlab="", ylab="")
points(factor(subs_count, levels=subs_count), real_time, col="black", pch="o")
lines(factor(subs_count, levels=subs_count), real_time, col="black", lty=1, lwd=2)
title(main="Зависимость задержки от фактора", xlab="Кол-во подписчиков", ylab="Задержка (нс)")
points(factor(subs_count, levels=subs_count), cpu_time, col="red", pch="X")
lines(factor(subs_count, levels=subs_count), cpu_time, col="red", lty=2, lwd=2)
legend("bottomright", legend=c("Время отправки (нс)", "Время отправки CPU (нс)"), col=c("black", "red"), lty=c(1, 2), pch=c("o", "X"), ncol=1)

plot(factor(subs_count, levels=subs_count), bytes_per_second, type="o", col="black", lty=0, ylim=c(-18690568346.27815, 44063080450.4655), xlab="", ylab="")
points(factor(subs_count, levels=subs_count), bytes_per_second, col="black", pch="o")
lines(factor(subs_count, levels=subs_count), bytes_per_second, col="black", lty=1, lwd=2)
title(main="Зависимость широты пропускания от фактора", xlab="Кол-во подписчиков", ylab="Широта пропускания (байт/сек)")
text( factor(subs_count, levels=subs_count), bytes_per_second, labels=bytes_per_second, cex= 0.7, pos=3)
points(factor(subs_count, levels=subs_count), manual_bandwidth, col="red", pch="X")
lines(factor(subs_count, levels=subs_count), manual_bandwidth, col="red", lty=2, lwd=2)
text( factor(subs_count, levels=subs_count), manual_bandwidth, labels=manual_bandwidth, cex= 0.7, pos=3)
legend("bottomright", legend=c("Широта пропускания публикующего (б/с)", "Широта пропускания принимающего (б/с)"), col=c("black", "red"), lty=c(1, 2), pch=c("o", "X"), ncol=1)

Benchmark name is “PublisherFixture/ROS_BM_Publish_method” by var=subs_count where size=16777216 buffer=1

#png(filename="plot.png", width = 1600, height = 900)
subs_count <- c(1, 2, 4, 8)
real_time <- c(21395027.363643862, 22559426.36559212, 23292156.30967273, 26143153.374057334)
cpu_time <- c(20282776.990910977, 21285161.103121914, 21914477.358061578, 22511168.3370364)
bytes_per_second <- c(784414946.7656333, 1487469904.2389154, 2881641092.722139, 5182736990.753264)
manual_bandwidth <- c(25394987.034445845, 66693479.00302472, 133697911.92292611, 170878241.28796715)
manual_latency <- c(1127483215.9, 1008205188.7, 1005167778.25, 1256933917.45)
df <- data.frame("factor"=subs_count, "Время отправки (нс)"=real_time, "Время отправки CPU (нс)"=cpu_time, "Широта пропускания публикующего (б/с)"=bytes_per_second, "Широта пропускания принимающего (б/с)"=manual_bandwidth, "Задержка передачи (нс)"=manual_latency)
plot(factor(subs_count, levels=subs_count), real_time, type="o", col="black", lty=0, ylim=c(13443104.569478527, 32982825.795489784), xlab="", ylab="")
points(factor(subs_count, levels=subs_count), real_time, col="black", pch="o")
lines(factor(subs_count, levels=subs_count), real_time, col="black", lty=1, lwd=2)
title(main="Зависимость задержки от фактора", xlab="Кол-во подписчиков", ylab="Задержка (нс)")
points(factor(subs_count, levels=subs_count), cpu_time, col="red", pch="X")
lines(factor(subs_count, levels=subs_count), cpu_time, col="red", lty=2, lwd=2)
legend("bottomright", legend=c("Время отправки (нс)", "Время отправки CPU (нс)"), col=c("black", "red"), lty=c(1, 2), pch=c("o", "X"), ncol=1)

plot(factor(subs_count, levels=subs_count), bytes_per_second, type="o", col="black", lty=0, ylim=c(-3297358370.177779, 8505490347.965489), xlab="", ylab="")
points(factor(subs_count, levels=subs_count), bytes_per_second, col="black", pch="o")
lines(factor(subs_count, levels=subs_count), bytes_per_second, col="black", lty=1, lwd=2)
title(main="Зависимость широты пропускания от фактора", xlab="Кол-во подписчиков", ylab="Широта пропускания (байт/сек)")
text( factor(subs_count, levels=subs_count), bytes_per_second, labels=bytes_per_second, cex= 0.7, pos=3)
points(factor(subs_count, levels=subs_count), manual_bandwidth, col="red", pch="X")
lines(factor(subs_count, levels=subs_count), manual_bandwidth, col="red", lty=2, lwd=2)
text( factor(subs_count, levels=subs_count), manual_bandwidth, labels=manual_bandwidth, cex= 0.7, pos=3)
legend("bottomright", legend=c("Широта пропускания публикующего (б/с)", "Широта пропускания принимающего (б/с)"), col=c("black", "red"), lty=c(1, 2), pch=c("o", "X"), ncol=1)

Benchmark name is “PublisherFixture/ROS_BM_Publish_method” by var=subs_count where size=16777216 buffer=10

#png(filename="plot.png", width = 1600, height = 900)
subs_count <- c(1, 2, 4, 8)
real_time <- c(21004428.776471764, 22561735.027286913, 23504962.296752755, 26556223.67240634)
cpu_time <- c(20058544.814708058, 21388009.081821375, 22159873.264530275, 22748359.231025398)
bytes_per_second <- c(798853509.4188143, 1487560472.1948926, 2856000457.834505, 5096349623.214842)
manual_bandwidth <- c(17397175.311926328, 57474150.51280172, 133653012.92550774, 197037880.00146163)
manual_latency <- c(1317382247.15, 1075517916.8, 1005367566.55, 1190112701.95)
df <- data.frame("factor"=subs_count, "Время отправки (нс)"=real_time, "Время отправки CPU (нс)"=cpu_time, "Широта пропускания публикующего (б/с)"=bytes_per_second, "Широта пропускания принимающего (б/с)"=manual_bandwidth, "Задержка передачи (нс)"=manual_latency)
plot(factor(subs_count, levels=subs_count), real_time, type="o", col="black", lty=0, ylim=c(13055178.483374871, 33559590.00373952), xlab="", ylab="")
points(factor(subs_count, levels=subs_count), real_time, col="black", pch="o")
lines(factor(subs_count, levels=subs_count), real_time, col="black", lty=1, lwd=2)
title(main="Зависимость задержки от фактора", xlab="Кол-во подписчиков", ylab="Задержка (нс)")
points(factor(subs_count, levels=subs_count), cpu_time, col="red", pch="X")
lines(factor(subs_count, levels=subs_count), cpu_time, col="red", lty=2, lwd=2)
legend("bottomright", legend=c("Время отправки (нс)", "Время отправки CPU (нс)"), col=c("black", "red"), lty=c(1, 2), pch=c("o", "X"), ncol=1)

plot(factor(subs_count, levels=subs_count), bytes_per_second, type="o", col="black", lty=0, ylim=c(-3203343491.3774934, 8317090289.904261), xlab="", ylab="")
points(factor(subs_count, levels=subs_count), bytes_per_second, col="black", pch="o")
lines(factor(subs_count, levels=subs_count), bytes_per_second, col="black", lty=1, lwd=2)
title(main="Зависимость широты пропускания от фактора", xlab="Кол-во подписчиков", ylab="Широта пропускания (байт/сек)")
text( factor(subs_count, levels=subs_count), bytes_per_second, labels=bytes_per_second, cex= 0.7, pos=3)
points(factor(subs_count, levels=subs_count), manual_bandwidth, col="red", pch="X")
lines(factor(subs_count, levels=subs_count), manual_bandwidth, col="red", lty=2, lwd=2)
text( factor(subs_count, levels=subs_count), manual_bandwidth, labels=manual_bandwidth, cex= 0.7, pos=3)
legend("bottomright", legend=c("Широта пропускания публикующего (б/с)", "Широта пропускания принимающего (б/с)"), col=c("black", "red"), lty=c(1, 2), pch=c("o", "X"), ncol=1)

Benchmark name is “PublisherFixture/ROS_BM_Publish_method” by var=subs_count where size=16777216 buffer=100

#png(filename="plot.png", width = 1600, height = 900)
subs_count <- c(1, 2, 4, 8)
real_time <- c(20703334.917135566, 22355699.803196214, 23068276.403340254, 25119723.291980334)
cpu_time <- c(20001775.965714283, 21274983.38709595, 21873380.620002083, 22583206.471997075)
bytes_per_second <- c(810590878.1915822, 1501298809.8137298, 2909598738.8389, 5360592562.3836975)
manual_bandwidth <- c(13619220.63213782, 51800864.92281709, 130036593.07107392, 156218973.88218027)
manual_latency <- c(1411569675.05, 1129658543.0, 1032974701.15, 1341391983.25)
df <- data.frame("factor"=subs_count, "Время отправки (нс)"=real_time, "Время отправки CPU (нс)"=cpu_time, "Широта пропускания публикующего (б/с)"=bytes_per_second, "Широта пропускания принимающего (б/с)"=manual_bandwidth, "Задержка передачи (нс)"=manual_latency)
plot(factor(subs_count, levels=subs_count), real_time, type="o", col="black", lty=0, ylim=c(15172651.749647237, 29948847.50804738), xlab="", ylab="")
points(factor(subs_count, levels=subs_count), real_time, col="black", pch="o")
lines(factor(subs_count, levels=subs_count), real_time, col="black", lty=1, lwd=2)
title(main="Зависимость задержки от фактора", xlab="Кол-во подписчиков", ylab="Задержка (нс)")
points(factor(subs_count, levels=subs_count), cpu_time, col="red", pch="X")
lines(factor(subs_count, levels=subs_count), cpu_time, col="red", lty=2, lwd=2)
legend("bottomright", legend=c("Время отправки (нс)", "Время отправки CPU (нс)"), col=c("black", "red"), lty=c(1, 2), pch=c("o", "X"), ncol=1)

plot(factor(subs_count, levels=subs_count), bytes_per_second, type="o", col="black", lty=0, ylim=c(-3100243900.0587006, 8474455683.074536), xlab="", ylab="")
points(factor(subs_count, levels=subs_count), bytes_per_second, col="black", pch="o")
lines(factor(subs_count, levels=subs_count), bytes_per_second, col="black", lty=1, lwd=2)
title(main="Зависимость широты пропускания от фактора", xlab="Кол-во подписчиков", ylab="Широта пропускания (байт/сек)")
text( factor(subs_count, levels=subs_count), bytes_per_second, labels=bytes_per_second, cex= 0.7, pos=3)
points(factor(subs_count, levels=subs_count), manual_bandwidth, col="red", pch="X")
lines(factor(subs_count, levels=subs_count), manual_bandwidth, col="red", lty=2, lwd=2)
text( factor(subs_count, levels=subs_count), manual_bandwidth, labels=manual_bandwidth, cex= 0.7, pos=3)
legend("bottomright", legend=c("Широта пропускания публикующего (б/с)", "Широта пропускания принимающего (б/с)"), col=c("black", "red"), lty=c(1, 2), pch=c("o", "X"), ncol=1)

Benchmark name is “PublisherFixture/ROS_BM_Publish_method” by var=subs_count where size=16777216 buffer=1000

#png(filename="plot.png", width = 1600, height = 900)
subs_count <- c(1, 2, 4, 8)
real_time <- c(20928469.642888427, 22414016.296895057, 23347286.599988975, 25506102.50713297)
cpu_time <- c(20107569.845712792, 21266647.921870433, 22050606.196670894, 22445104.485725712)
bytes_per_second <- c(802032047.0617198, 1497391531.0611567, 2874616568.07146, 5320514158.94353)
manual_bandwidth <- c(19075255.851903733, 50552285.35404814, 124018878.37218018, 147643137.72752073)
manual_latency <- c(1282624062.85, 992827572.75, 1032704555.4, 1297891271.6)
df <- data.frame("factor"=subs_count, "Время отправки (нс)"=real_time, "Время отправки CPU (нс)"=cpu_time, "Широта пропускания публикующего (б/с)"=bytes_per_second, "Широта пропускания принимающего (б/с)"=manual_bandwidth, "Задержка передачи (нс)"=manual_latency)
plot(factor(subs_count, levels=subs_count), real_time, type="o", col="black", lty=0, ylim=c(13066985.301378, 32546687.05146776), xlab="", ylab="")
points(factor(subs_count, levels=subs_count), real_time, col="black", pch="o")
lines(factor(subs_count, levels=subs_count), real_time, col="black", lty=1, lwd=2)
title(main="Зависимость задержки от фактора", xlab="Кол-во подписчиков", ylab="Задержка (нс)")
points(factor(subs_count, levels=subs_count), cpu_time, col="red", pch="X")
lines(factor(subs_count, levels=subs_count), cpu_time, col="red", lty=2, lwd=2)
legend("bottomright", legend=c("Время отправки (нс)", "Время отправки CPU (нс)"), col=c("black", "red"), lty=c(1, 2), pch=c("o", "X"), ncol=1)

plot(factor(subs_count, levels=subs_count), bytes_per_second, type="o", col="black", lty=0, ylim=c(-3418626237.5485845, 8758215652.344019), xlab="", ylab="")
points(factor(subs_count, levels=subs_count), bytes_per_second, col="black", pch="o")
lines(factor(subs_count, levels=subs_count), bytes_per_second, col="black", lty=1, lwd=2)
title(main="Зависимость широты пропускания от фактора", xlab="Кол-во подписчиков", ylab="Широта пропускания (байт/сек)")
text( factor(subs_count, levels=subs_count), bytes_per_second, labels=bytes_per_second, cex= 0.7, pos=3)
points(factor(subs_count, levels=subs_count), manual_bandwidth, col="red", pch="X")
lines(factor(subs_count, levels=subs_count), manual_bandwidth, col="red", lty=2, lwd=2)
text( factor(subs_count, levels=subs_count), manual_bandwidth, labels=manual_bandwidth, cex= 0.7, pos=3)
legend("bottomright", legend=c("Широта пропускания публикующего (б/с)", "Широта пропускания принимающего (б/с)"), col=c("black", "red"), lty=c(1, 2), pch=c("o", "X"), ncol=1)

Benchmark name is “PublisherFixture/ROS_BM_Publish_method” by var=subs_count where size=16777216 buffer=10000

#png(filename="plot.png", width = 1600, height = 900)
subs_count <- c(1, 2, 4, 8)
real_time <- c(21080164.358799644, 22575119.67813741, 23305184.95172296, 25385952.37243373)
cpu_time <- c(20199333.585295126, 21325079.599998984, 21952144.58275696, 22495410.279310785)
bytes_per_second <- c(795992774.0525539, 1486570954.332946, 2880529515.95339, 5306957246.9734745)
manual_bandwidth <- c(26685113.049180597, 62585798.89146529, 104369022.20619102, 152538314.27993858)
manual_latency <- c(1113078642.0, 1032681598.45, 1106952711.4, 1372224844.9)
df <- data.frame("factor"=subs_count, "Время отправки (нс)"=real_time, "Время отправки CPU (нс)"=cpu_time, "Широта пропускания публикующего (б/с)"=bytes_per_second, "Широта пропускания принимающего (б/с)"=manual_bandwidth, "Задержка передачи (нс)"=manual_latency)
plot(factor(subs_count, levels=subs_count), real_time, type="o", col="black", lty=0, ylim=c(15146209.055668196, 30439076.90206066), xlab="", ylab="")
points(factor(subs_count, levels=subs_count), real_time, col="black", pch="o")
lines(factor(subs_count, levels=subs_count), real_time, col="black", lty=1, lwd=2)
title(main="Зависимость задержки от фактора", xlab="Кол-во подписчиков", ylab="Задержка (нс)")
points(factor(subs_count, levels=subs_count), cpu_time, col="red", pch="X")
lines(factor(subs_count, levels=subs_count), cpu_time, col="red", lty=2, lwd=2)
legend("bottomright", legend=c("Время отправки (нс)", "Время отправки CPU (нс)"), col=c("black", "red"), lty=c(1, 2), pch=c("o", "X"), ncol=1)

plot(factor(subs_count, levels=subs_count), bytes_per_second, type="o", col="black", lty=0, ylim=c(-3080798821.394832, 8414441181.417488), xlab="", ylab="")
points(factor(subs_count, levels=subs_count), bytes_per_second, col="black", pch="o")
lines(factor(subs_count, levels=subs_count), bytes_per_second, col="black", lty=1, lwd=2)
title(main="Зависимость широты пропускания от фактора", xlab="Кол-во подписчиков", ylab="Широта пропускания (байт/сек)")
text( factor(subs_count, levels=subs_count), bytes_per_second, labels=bytes_per_second, cex= 0.7, pos=3)
points(factor(subs_count, levels=subs_count), manual_bandwidth, col="red", pch="X")
lines(factor(subs_count, levels=subs_count), manual_bandwidth, col="red", lty=2, lwd=2)
text( factor(subs_count, levels=subs_count), manual_bandwidth, labels=manual_bandwidth, cex= 0.7, pos=3)
legend("bottomright", legend=c("Широта пропускания публикующего (б/с)", "Широта пропускания принимающего (б/с)"), col=c("black", "red"), lty=c(1, 2), pch=c("o", "X"), ncol=1)

Benchmark name is “PublisherFixture/ROS_BM_Publish_method” by var=subs_count where size=67108864 buffer=1

#png(filename="plot.png", width = 1600, height = 900)
subs_count <- c(1, 2, 4, 8)
real_time <- c(86678925.24996433, 89927750.20001318, 93498160.96246286, 120207000.35001254)
cpu_time <- c(85284846.61250034, 85783181.7124989, 88778417.11252189, 94906323.32498308)
bytes_per_second <- c(774956270.4606626, 1492840055.6196458, 2872424553.5251665, 4522665854.849938)
manual_bandwidth <- c(19110785.712584555, 39672064.81443493, 76775254.21171837, 129915114.14094861)
manual_latency <- c(3856921917.3, 3799002010.5, 3926255453.55, 4631043895.9)
df <- data.frame("factor"=subs_count, "Время отправки (нс)"=real_time, "Время отправки CPU (нс)"=cpu_time, "Широта пропускания публикующего (б/с)"=bytes_per_second, "Широта пропускания принимающего (б/с)"=manual_bandwidth, "Задержка передачи (нс)"=manual_latency)
plot(factor(subs_count, levels=subs_count), real_time, type="o", col="black", lty=0, ylim=c(48133410.7648133, 157358436.19769958), xlab="", ylab="")
points(factor(subs_count, levels=subs_count), real_time, col="black", pch="o")
lines(factor(subs_count, levels=subs_count), real_time, col="black", lty=1, lwd=2)
title(main="Зависимость задержки от фактора", xlab="Кол-во подписчиков", ylab="Задержка (нс)")
points(factor(subs_count, levels=subs_count), cpu_time, col="red", pch="X")
lines(factor(subs_count, levels=subs_count), cpu_time, col="red", lty=2, lwd=2)
legend("bottomright", legend=c("Время отправки (нс)", "Время отправки CPU (нс)"), col=c("black", "red"), lty=c(1, 2), pch=c("o", "X"), ncol=1)

plot(factor(subs_count, levels=subs_count), bytes_per_second, type="o", col="black", lty=0, ylim=c(-3021952061.340907, 7563728701.903429), xlab="", ylab="")
points(factor(subs_count, levels=subs_count), bytes_per_second, col="black", pch="o")
lines(factor(subs_count, levels=subs_count), bytes_per_second, col="black", lty=1, lwd=2)
title(main="Зависимость широты пропускания от фактора", xlab="Кол-во подписчиков", ylab="Широта пропускания (байт/сек)")
text( factor(subs_count, levels=subs_count), bytes_per_second, labels=bytes_per_second, cex= 0.7, pos=3)
points(factor(subs_count, levels=subs_count), manual_bandwidth, col="red", pch="X")
lines(factor(subs_count, levels=subs_count), manual_bandwidth, col="red", lty=2, lwd=2)
text( factor(subs_count, levels=subs_count), manual_bandwidth, labels=manual_bandwidth, cex= 0.7, pos=3)
legend("bottomright", legend=c("Широта пропускания публикующего (б/с)", "Широта пропускания принимающего (б/с)"), col=c("black", "red"), lty=c(1, 2), pch=c("o", "X"), ncol=1)

Benchmark name is “PublisherFixture/ROS_BM_Publish_method” by var=subs_count where size=67108864 buffer=10

#png(filename="plot.png", width = 1600, height = 900)
subs_count <- c(1, 2, 4, 8)
real_time <- c(86175066.38751139, 90571704.1999992, 91232388.98746423, 135832183.7201038)
cpu_time <- c(84428311.06249854, 85892568.46249923, 87516438.4750036, 96267461.45996548)
bytes_per_second <- c(779016401.2050602, 1481918626.544727, 2944440941.3977957, 4054744034.389286)
manual_bandwidth <- c(17568500.79245288, 34573926.6295575, 67084073.830885425, 110213680.28714296)
manual_latency <- c(3821787509.6, 3884474346.9, 4003217457.1, 4875863732.6)
df <- data.frame("factor"=subs_count, "Время отправки (нс)"=real_time, "Время отправки CPU (нс)"=cpu_time, "Широта пропускания публикующего (б/с)"=bytes_per_second, "Широта пропускания принимающего (б/с)"=manual_bandwidth, "Задержка передачи (нс)"=manual_latency)
plot(factor(subs_count, levels=subs_count), real_time, type="o", col="black", lty=0, ylim=c(27770450.18209467, 192490044.60050768), xlab="", ylab="")
points(factor(subs_count, levels=subs_count), real_time, col="black", pch="o")
lines(factor(subs_count, levels=subs_count), real_time, col="black", lty=1, lwd=2)
title(main="Зависимость задержки от фактора", xlab="Кол-во подписчиков", ylab="Задержка (нс)")
points(factor(subs_count, levels=subs_count), cpu_time, col="red", pch="X")
lines(factor(subs_count, levels=subs_count), cpu_time, col="red", lty=2, lwd=2)
legend("bottomright", legend=c("Время отправки (нс)", "Время отправки CPU (нс)"), col=c("black", "red"), lty=c(1, 2), pch=c("o", "X"), ncol=1)

plot(factor(subs_count, levels=subs_count), bytes_per_second, type="o", col="black", lty=0, ylim=c(-3032958572.4941654, 7105271107.675904), xlab="", ylab="")
points(factor(subs_count, levels=subs_count), bytes_per_second, col="black", pch="o")
lines(factor(subs_count, levels=subs_count), bytes_per_second, col="black", lty=1, lwd=2)
title(main="Зависимость широты пропускания от фактора", xlab="Кол-во подписчиков", ylab="Широта пропускания (байт/сек)")
text( factor(subs_count, levels=subs_count), bytes_per_second, labels=bytes_per_second, cex= 0.7, pos=3)
points(factor(subs_count, levels=subs_count), manual_bandwidth, col="red", pch="X")
lines(factor(subs_count, levels=subs_count), manual_bandwidth, col="red", lty=2, lwd=2)
text( factor(subs_count, levels=subs_count), manual_bandwidth, labels=manual_bandwidth, cex= 0.7, pos=3)
legend("bottomright", legend=c("Широта пропускания публикующего (б/с)", "Широта пропускания принимающего (б/с)"), col=c("black", "red"), lty=c(1, 2), pch=c("o", "X"), ncol=1)

Benchmark name is “PublisherFixture/ROS_BM_Publish_method” by var=subs_count where size=67108864 buffer=100

#png(filename="plot.png", width = 1600, height = 900)
subs_count <- c(1, 2, 4, 8)
real_time <- c(85672930.42501661, 88680996.94998363, 92551044.3624944, 122985828.25716428)
cpu_time <- c(83528424.77499607, 86191063.26250406, 88371835.92498264, 94697308.01428925)
bytes_per_second <- c(783521912.9193466, 1514139480.1089492, 2902150669.535243, 4432288992.212332)
manual_bandwidth <- c(17636101.26386756, 34611524.52859531, 66992589.310907885, 114933284.83632219)
manual_latency <- c(3807758396.2, 3880524864.1, 4008701339.4, 4698611895.5)
df <- data.frame("factor"=subs_count, "Время отправки (нс)"=real_time, "Время отправки CPU (нс)"=cpu_time, "Широта пропускания публикующего (б/с)"=bytes_per_second, "Широта пропускания принимающего (б/с)"=manual_bandwidth, "Задержка передачи (нс)"=manual_latency)
plot(factor(subs_count, levels=subs_count), real_time, type="o", col="black", lty=0, ylim=c(40685568.85501691, 165828684.17714342), xlab="", ylab="")
points(factor(subs_count, levels=subs_count), real_time, col="black", pch="o")
lines(factor(subs_count, levels=subs_count), real_time, col="black", lty=1, lwd=2)
title(main="Зависимость задержки от фактора", xlab="Кол-во подписчиков", ylab="Задержка (нс)")
points(factor(subs_count, levels=subs_count), cpu_time, col="red", pch="X")
lines(factor(subs_count, levels=subs_count), cpu_time, col="red", lty=2, lwd=2)
legend("bottomright", legend=c("Время отправки (нс)", "Время отправки CPU (нс)"), col=c("black", "red"), lty=c(1, 2), pch=c("o", "X"), ncol=1)

plot(factor(subs_count, levels=subs_count), bytes_per_second, type="o", col="black", lty=0, ylim=c(-3009635156.358952, 7459560249.835152), xlab="", ylab="")
points(factor(subs_count, levels=subs_count), bytes_per_second, col="black", pch="o")
lines(factor(subs_count, levels=subs_count), bytes_per_second, col="black", lty=1, lwd=2)
title(main="Зависимость широты пропускания от фактора", xlab="Кол-во подписчиков", ylab="Широта пропускания (байт/сек)")
text( factor(subs_count, levels=subs_count), bytes_per_second, labels=bytes_per_second, cex= 0.7, pos=3)
points(factor(subs_count, levels=subs_count), manual_bandwidth, col="red", pch="X")
lines(factor(subs_count, levels=subs_count), manual_bandwidth, col="red", lty=2, lwd=2)
text( factor(subs_count, levels=subs_count), manual_bandwidth, labels=manual_bandwidth, cex= 0.7, pos=3)
legend("bottomright", legend=c("Широта пропускания публикующего (б/с)", "Широта пропускания принимающего (б/с)"), col=c("black", "red"), lty=c(1, 2), pch=c("o", "X"), ncol=1)

Benchmark name is “PublisherFixture/ROS_BM_Publish_method” by var=subs_count where size=67108864 buffer=1000

#png(filename="plot.png", width = 1600, height = 900)
subs_count <- c(1, 2, 4, 8)
real_time <- c(84531585.93753187, 89716667.31254117, 92941189.26244438, 128046437.21431474)
cpu_time <- c(83198716.40000471, 85706402.67500095, 88493378.37500286, 94568736.32858397)
bytes_per_second <- c(794131967.7890902, 1496490513.9038959, 2888397199.7083015, 4238887680.302912)
manual_bandwidth <- c(17661296.76422714, 34607090.33394261, 67168469.40286735, 114433365.43745105)
manual_latency <- c(3802408177.5, 3880976503.3, 3998641182.8, 4699079887.8)
df <- data.frame("factor"=subs_count, "Время отправки (нс)"=real_time, "Время отправки CPU (нс)"=cpu_time, "Широта пропускания публикующего (б/с)"=bytes_per_second, "Широта пропускания принимающего (б/с)"=manual_bandwidth, "Задержка передачи (нс)"=manual_latency)
plot(factor(subs_count, levels=subs_count), real_time, type="o", col="black", lty=0, ylim=c(41229581.81315755, 170015571.8011619), xlab="", ylab="")
points(factor(subs_count, levels=subs_count), real_time, col="black", pch="o")
lines(factor(subs_count, levels=subs_count), real_time, col="black", lty=1, lwd=2)
title(main="Зависимость задержки от фактора", xlab="Кол-во подписчиков", ylab="Задержка (нс)")
points(factor(subs_count, levels=subs_count), cpu_time, col="red", pch="X")
lines(factor(subs_count, levels=subs_count), cpu_time, col="red", lty=2, lwd=2)
legend("bottomright", legend=c("Время отправки (нс)", "Время отправки CPU (нс)"), col=c("black", "red"), lty=c(1, 2), pch=c("o", "X"), ncol=1)

plot(factor(subs_count, levels=subs_count), bytes_per_second, type="o", col="black", lty=0, ylim=c(-2784250816.1887536, 7040799793.255894), xlab="", ylab="")
points(factor(subs_count, levels=subs_count), bytes_per_second, col="black", pch="o")
lines(factor(subs_count, levels=subs_count), bytes_per_second, col="black", lty=1, lwd=2)
title(main="Зависимость широты пропускания от фактора", xlab="Кол-во подписчиков", ylab="Широта пропускания (байт/сек)")
text( factor(subs_count, levels=subs_count), bytes_per_second, labels=bytes_per_second, cex= 0.7, pos=3)
points(factor(subs_count, levels=subs_count), manual_bandwidth, col="red", pch="X")
lines(factor(subs_count, levels=subs_count), manual_bandwidth, col="red", lty=2, lwd=2)
text( factor(subs_count, levels=subs_count), manual_bandwidth, labels=manual_bandwidth, cex= 0.7, pos=3)
legend("bottomright", legend=c("Широта пропускания публикующего (б/с)", "Широта пропускания принимающего (б/с)"), col=c("black", "red"), lty=c(1, 2), pch=c("o", "X"), ncol=1)

Benchmark name is “PublisherFixture/ROS_BM_Publish_method” by var=subs_count where size=67108864 buffer=10000

#png(filename="plot.png", width = 1600, height = 900)
subs_count <- c(1, 2, 4, 8)
real_time <- c(84508287.60006744, 89915839.62508684, 93057628.11248997, 136672580.1200664)
cpu_time <- c(83497380.48749842, 86114938.05000237, 87969822.2874964, 95237181.67998594)
bytes_per_second <- c(794310429.5221562, 1493074867.8146243, 2884831442.8780107, 3988117682.2469215)
manual_bandwidth <- c(13972486.088328427, 27468889.404516257, 53351514.60043373, 93005388.66803208)
manual_latency <- c(3073897082.7, 3127171751.1, 3220132418.9, 4690898936.3)
df <- data.frame("factor"=subs_count, "Время отправки (нс)"=real_time, "Время отправки CPU (нс)"=cpu_time, "Широта пропускания публикующего (б/с)"=bytes_per_second, "Широта пропускания принимающего (б/с)"=manual_bandwidth, "Задержка передачи (нс)"=manual_latency)
plot(factor(subs_count, levels=subs_count), real_time, type="o", col="black", lty=0, ylim=c(32104716.581446707, 188065244.0261181), xlab="", ylab="")
points(factor(subs_count, levels=subs_count), real_time, col="black", pch="o")
lines(factor(subs_count, levels=subs_count), real_time, col="black", lty=1, lwd=2)
title(main="Зависимость задержки от фактора", xlab="Кол-во подписчиков", ylab="Задержка (нс)")
points(factor(subs_count, levels=subs_count), cpu_time, col="red", pch="X")
lines(factor(subs_count, levels=subs_count), cpu_time, col="red", lty=2, lwd=2)
legend("bottomright", legend=c("Время отправки (нс)", "Время отправки CPU (нс)"), col=c("black", "red"), lty=c(1, 2), pch=c("o", "X"), ncol=1)

plot(factor(subs_count, levels=subs_count), bytes_per_second, type="o", col="black", lty=0, ylim=c(-2731505529.4491696, 6733595697.784419), xlab="", ylab="")
points(factor(subs_count, levels=subs_count), bytes_per_second, col="black", pch="o")
lines(factor(subs_count, levels=subs_count), bytes_per_second, col="black", lty=1, lwd=2)
title(main="Зависимость широты пропускания от фактора", xlab="Кол-во подписчиков", ylab="Широта пропускания (байт/сек)")
text( factor(subs_count, levels=subs_count), bytes_per_second, labels=bytes_per_second, cex= 0.7, pos=3)
points(factor(subs_count, levels=subs_count), manual_bandwidth, col="red", pch="X")
lines(factor(subs_count, levels=subs_count), manual_bandwidth, col="red", lty=2, lwd=2)
text( factor(subs_count, levels=subs_count), manual_bandwidth, labels=manual_bandwidth, cex= 0.7, pos=3)
legend("bottomright", legend=c("Широта пропускания публикующего (б/с)", "Широта пропускания принимающего (б/с)"), col=c("black", "red"), lty=c(1, 2), pch=c("o", "X"), ncol=1)

Benchmark name is “PublisherFixture/ROS_BM_Publish_method” by var=size where subs_count=1 buffer=1

#png(filename="plot.png", width = 1600, height = 900)
size <- c(1024, 4096, 16384, 65536, 262144, 1048576, 4194304, 16777216, 67108864)
real_time <- c(4580.186172553285, 5141.29448106764, 11413.245646123949, 35241.86476183732, 114268.43880865749, 1045110.7708889504, 3753850.3210739205, 21395027.363643862, 86678925.24996433)
cpu_time <- c(3979.014066657179, 4555.869325588748, 10687.832977406468, 33241.20863759325, 108479.34467634936, 1006048.5644091123, 3713596.038016802, 20282776.990910977, 85284846.61250034)
bytes_per_second <- c(223577799.00550812, 796736934.3596822, 1444943827.793212, 1904870091.11708, 2323881701.4534497, 1003449314.9936724, 1217603642.0833662, 784414946.7656333, 774956270.4606626)
manual_bandwidth <- c(285570646.1227563, 562460814.8161839, 4854025925.934568, 1594122789.7331998, 561893310.21282, 105805925.1746181, 16458417.004081905, 25394987.034445845, 19110785.712584555)
manual_latency <- c(100541167.69730183, 73825278.00071314, 3676285.601414365, 39326305.28582083, 76813681.20076752, 137343184.1157684, 590373219.65, 1127483215.9, 3856921917.3)
df <- data.frame("factor"=size, "Время отправки (нс)"=real_time, "Время отправки CPU (нс)"=cpu_time, "Широта пропускания публикующего (б/с)"=bytes_per_second, "Широта пропускания принимающего (б/с)"=manual_bandwidth, "Задержка передачи (нс)"=manual_latency)
plot(factor(size, levels=size), real_time, type="o", col="black", lty=0, ylim=c(-47397422.84601894, 134080327.11004992), xlab="", ylab="")
points(factor(size, levels=size), real_time, col="black", pch="o")
lines(factor(size, levels=size), real_time, col="black", lty=1, lwd=2)
title(main="Зависимость задержки от фактора", xlab="Размер сообщения (б)", ylab="Задержка (нс)")
points(factor(size, levels=size), cpu_time, col="red", pch="X")
lines(factor(size, levels=size), cpu_time, col="red", lty=2, lwd=2)
legend("bottomright", legend=c("Время отправки (нс)", "Время отправки CPU (нс)"), col=c("black", "red"), lty=c(1, 2), pch=c("o", "X"), ncol=1)

plot(factor(size, levels=size), bytes_per_second, type="o", col="black", lty=0, ylim=c(-3966951585.599926, 8837435928.538576), xlab="", ylab="")
points(factor(size, levels=size), bytes_per_second, col="black", pch="o")
lines(factor(size, levels=size), bytes_per_second, col="black", lty=1, lwd=2)
title(main="Зависимость широты пропускания от фактора", xlab="Размер сообщения (б)", ylab="Широта пропускания (байт/сек)")
text( factor(size, levels=size), bytes_per_second, labels=bytes_per_second, cex= 0.7, pos=3)
points(factor(size, levels=size), manual_bandwidth, col="red", pch="X")
lines(factor(size, levels=size), manual_bandwidth, col="red", lty=2, lwd=2)
text( factor(size, levels=size), manual_bandwidth, labels=manual_bandwidth, cex= 0.7, pos=3)
legend("bottomright", legend=c("Широта пропускания публикующего (б/с)", "Широта пропускания принимающего (б/с)"), col=c("black", "red"), lty=c(1, 2), pch=c("o", "X"), ncol=1)

Benchmark name is “PublisherFixture/ROS_BM_Publish_method” by var=size where subs_count=1 buffer=10

#png(filename="plot.png", width = 1600, height = 900)
size <- c(1024, 4096, 16384, 65536, 262144, 1048576, 4194304, 16777216, 67108864)
real_time <- c(4682.1144877890165, 5086.4825499693825, 10797.271739557818, 32294.890055415395, 93697.43355981298, 1043938.4474867955, 2538826.699143001, 21004428.776471764, 86175066.38751139)
cpu_time <- c(4022.6201363443483, 4520.956539210994, 10110.794076117785, 30496.115490451182, 89347.84447660146, 1009134.8073967369, 2497592.8508471227, 20058544.814708058, 84428311.06249854)
bytes_per_second <- c(218715403.4698433, 805315086.1682184, 1522427786.9583912, 2159542493.6796823, 2926476322.412967, 1004721114.4900757, 2222609749.2521906, 798853509.4188143, 779016401.2050602)
manual_bandwidth <- c(266508563.34648475, 541051935.4185402, 4244976091.8839583, 809782798.6633061, 489084389.21603614, 71085398.25787535, 38100873.85264189, 17397175.311926328, 17568500.79245288)
manual_latency <- c(89514370.37282008, 77874221.18243358, 10023994.052193463, 51469032.88383031, 77811452.96430251, 152659687.22916666, 407792625.5516667, 1317382247.15, 3821787509.6)
df <- data.frame("factor"=size, "Время отправки (нс)"=real_time, "Время отправки CPU (нс)"=cpu_time, "Широта пропускания публикующего (б/с)"=bytes_per_second, "Широта пропускания принимающего (б/с)"=manual_bandwidth, "Задержка передачи (нс)"=manual_latency)
plot(factor(size, levels=size), real_time, type="o", col="black", lty=0, ylim=c(-45484096.9415737, 131663185.94922143), xlab="", ylab="")
points(factor(size, levels=size), real_time, col="black", pch="o")
lines(factor(size, levels=size), real_time, col="black", lty=1, lwd=2)
title(main="Зависимость задержки от фактора", xlab="Размер сообщения (б)", ylab="Задержка (нс)")
points(factor(size, levels=size), cpu_time, col="red", pch="X")
lines(factor(size, levels=size), cpu_time, col="red", lty=2, lwd=2)
legend("bottomright", legend=c("Время отправки (нс)", "Время отправки CPU (нс)"), col=c("black", "red"), lty=c(1, 2), pch=c("o", "X"), ncol=1)

plot(factor(size, levels=size), bytes_per_second, type="o", col="black", lty=0, ylim=c(-5046995807.421034, 9309369074.616919), xlab="", ylab="")
points(factor(size, levels=size), bytes_per_second, col="black", pch="o")
lines(factor(size, levels=size), bytes_per_second, col="black", lty=1, lwd=2)
title(main="Зависимость широты пропускания от фактора", xlab="Размер сообщения (б)", ylab="Широта пропускания (байт/сек)")
text( factor(size, levels=size), bytes_per_second, labels=bytes_per_second, cex= 0.7, pos=3)
points(factor(size, levels=size), manual_bandwidth, col="red", pch="X")
lines(factor(size, levels=size), manual_bandwidth, col="red", lty=2, lwd=2)
text( factor(size, levels=size), manual_bandwidth, labels=manual_bandwidth, cex= 0.7, pos=3)
legend("bottomright", legend=c("Широта пропускания публикующего (б/с)", "Широта пропускания принимающего (б/с)"), col=c("black", "red"), lty=c(1, 2), pch=c("o", "X"), ncol=1)

Benchmark name is “PublisherFixture/ROS_BM_Publish_method” by var=size where subs_count=1 buffer=100

#png(filename="plot.png", width = 1600, height = 900)
size <- c(1024, 4096, 16384, 65536, 262144, 1048576, 4194304, 16777216, 67108864)
real_time <- c(4696.130734695629, 4996.712260876187, 9838.876178620927, 27581.031056461135, 115074.4071538304, 1051105.2499288847, 2434603.9247404262, 20703334.917135566, 85672930.42501661)
cpu_time <- c(4043.0389562330433, 4484.187911371033, 9185.984708335725, 25898.2559040687, 109212.65418650089, 1004895.4915821294, 2402506.9499997115, 20001775.965714283, 83528424.77499607)
bytes_per_second <- c(218059518.18379253, 819773825.8472631, 1672845539.8542438, 2410643142.9612517, 2285440169.120406, 997716470.024121, 1876029897.5067196, 810590878.1915822, 783521912.9193466)
manual_bandwidth <- c(295981091.74113256, 519480747.8371477, 5039883825.957062, 939146864.5975126, 660527389.5495522, 90615069.17813474, 49531512.28005635, 13619220.63213782, 17636101.26386756)
manual_latency <- c(98827380.76116, 78586582.6695374, 6987833.432573368, 60921372.31911387, 68887668.59135279, 125700754.313254, 382650046.6, 1411569675.05, 3807758396.2)
df <- data.frame("factor"=size, "Время отправки (нс)"=real_time, "Время отправки CPU (нс)"=cpu_time, "Широта пропускания публикующего (б/с)"=bytes_per_second, "Широта пропускания принимающего (б/с)"=manual_bandwidth, "Задержка передачи (нс)"=manual_latency)
plot(factor(size, levels=size), real_time, type="o", col="black", lty=0, ylim=c(-44928978.958716705, 130605952.42268954), xlab="", ylab="")
points(factor(size, levels=size), real_time, col="black", pch="o")
lines(factor(size, levels=size), real_time, col="black", lty=1, lwd=2)
title(main="Зависимость задержки от фактора", xlab="Размер сообщения (б)", ylab="Задержка (нс)")
points(factor(size, levels=size), cpu_time, col="red", pch="X")
lines(factor(size, levels=size), cpu_time, col="red", lty=2, lwd=2)
legend("bottomright", legend=c("Время отправки (нс)", "Время отправки CPU (нс)"), col=c("black", "red"), lty=c(1, 2), pch=c("o", "X"), ncol=1)

plot(factor(size, levels=size), bytes_per_second, type="o", col="black", lty=0, ylim=c(-5524301809.221875, 10577804855.811075), xlab="", ylab="")
points(factor(size, levels=size), bytes_per_second, col="black", pch="o")
lines(factor(size, levels=size), bytes_per_second, col="black", lty=1, lwd=2)
title(main="Зависимость широты пропускания от фактора", xlab="Размер сообщения (б)", ylab="Широта пропускания (байт/сек)")
text( factor(size, levels=size), bytes_per_second, labels=bytes_per_second, cex= 0.7, pos=3)
points(factor(size, levels=size), manual_bandwidth, col="red", pch="X")
lines(factor(size, levels=size), manual_bandwidth, col="red", lty=2, lwd=2)
text( factor(size, levels=size), manual_bandwidth, labels=manual_bandwidth, cex= 0.7, pos=3)
legend("bottomright", legend=c("Широта пропускания публикующего (б/с)", "Широта пропускания принимающего (б/с)"), col=c("black", "red"), lty=c(1, 2), pch=c("o", "X"), ncol=1)

Benchmark name is “PublisherFixture/ROS_BM_Publish_method” by var=size where subs_count=1 buffer=1000

#png(filename="plot.png", width = 1600, height = 900)
size <- c(1024, 4096, 16384, 65536, 262144, 1048576, 4194304, 16777216, 67108864)
real_time <- c(4647.609275461621, 4914.350042001504, 10817.46587170375, 32410.539184549638, 83764.88011132626, 1044106.2189312959, 3573191.76375081, 20928469.642888427, 84531585.93753187)
cpu_time <- c(3996.525072522072, 4390.631452501739, 10111.225631437, 30571.879910891334, 80272.52386504423, 996014.952023052, 3540859.590603914, 20107569.845712792, 83198716.40000471)
bytes_per_second <- c(220334104.45400634, 833495450.3921818, 1552375281.0753336, 2039646241.2514234, 3139900191.558425, 1004412110.5288732, 1226689567.3281274, 802032047.0617198, 794131967.7890902)
manual_bandwidth <- c(233548707.55889267, 517619176.04281694, 3521025198.331669, 1267576171.691979, 692023701.5569701, 175012270.98146084, 28570435.29598547, 19075255.851903733, 17661296.76422714)
manual_latency <- c(98645086.48662971, 79166648.66358423, 12683969.933360163, 45286113.04486585, 78444876.04642949, 101784359.23296383, 376512161.325, 1282624062.85, 3802408177.5)
df <- data.frame("factor"=size, "Время отправки (нс)"=real_time, "Время отправки CPU (нс)"=cpu_time, "Широта пропускания публикующего (б/с)"=bytes_per_second, "Широта пропускания принимающего (б/с)"=manual_bandwidth, "Задержка передачи (нс)"=manual_latency)
plot(factor(size, levels=size), real_time, type="o", col="black", lty=0, ylim=c(-44491127.639548406, 129026710.1021528), xlab="", ylab="")
points(factor(size, levels=size), real_time, col="black", pch="o")
lines(factor(size, levels=size), real_time, col="black", lty=1, lwd=2)
title(main="Зависимость задержки от фактора", xlab="Размер сообщения (б)", ylab="Задержка (нс)")
points(factor(size, levels=size), cpu_time, col="red", pch="X")
lines(factor(size, levels=size), cpu_time, col="red", lty=2, lwd=2)
legend("bottomright", legend=c("Время отправки (нс)", "Время отправки CPU (нс)"), col=c("black", "red"), lty=c(1, 2), pch=c("o", "X"), ncol=1)

plot(factor(size, levels=size), bytes_per_second, type="o", col="black", lty=0, ylim=c(-3856161495.41033, 7394847990.506226), xlab="", ylab="")
points(factor(size, levels=size), bytes_per_second, col="black", pch="o")
lines(factor(size, levels=size), bytes_per_second, col="black", lty=1, lwd=2)
title(main="Зависимость широты пропускания от фактора", xlab="Размер сообщения (б)", ylab="Широта пропускания (байт/сек)")
text( factor(size, levels=size), bytes_per_second, labels=bytes_per_second, cex= 0.7, pos=3)
points(factor(size, levels=size), manual_bandwidth, col="red", pch="X")
lines(factor(size, levels=size), manual_bandwidth, col="red", lty=2, lwd=2)
text( factor(size, levels=size), manual_bandwidth, labels=manual_bandwidth, cex= 0.7, pos=3)
legend("bottomright", legend=c("Широта пропускания публикующего (б/с)", "Широта пропускания принимающего (б/с)"), col=c("black", "red"), lty=c(1, 2), pch=c("o", "X"), ncol=1)

Benchmark name is “PublisherFixture/ROS_BM_Publish_method” by var=size where subs_count=1 buffer=10000

#png(filename="plot.png", width = 1600, height = 900)
size <- c(1024, 4096, 16384, 65536, 262144, 1048576, 4194304, 16777216, 67108864)
real_time <- c(4677.977688931564, 4930.20967126802, 10032.899855836778, 30851.068553369067, 100852.87849219091, 1052824.5458658107, 2344889.4259120347, 21080164.358799644, 84508287.60006744)
cpu_time <- c(4032.751272340824, 4406.624640378626, 9360.39266823885, 29106.578206122278, 96188.6194666941, 1002082.1166906192, 2321858.0445348253, 20199333.585295126, 83497380.48749842)
bytes_per_second <- c(218914227.22643536, 830833871.4981556, 1634542267.3890026, 2187382139.450816, 2675212009.490981, 996056474.4295423, 2134439129.120278, 795992774.0525539, 794310429.5221562)
manual_bandwidth <- c(289649824.28957945, 532817554.3644816, 8555976419.073015, 1099325007.183746, 629218457.0725011, 142791755.3746472, 43746289.07796217, 26685113.049180597, 13972486.088328427)
manual_latency <- c(99219020.04579222, 78445081.83738217, 4338464.470109924, 46460204.54936122, 77162712.9916431, 102741443.81669703, 349799361.53166664, 1113078642.0, 3073897082.7)
df <- data.frame("factor"=size, "Время отправки (нс)"=real_time, "Время отправки CPU (нс)"=cpu_time, "Широта пропускания публикующего (б/с)"=bytes_per_second, "Широта пропускания принимающего (б/с)"=manual_bandwidth, "Задержка передачи (нс)"=manual_latency)
plot(factor(size, levels=size), real_time, type="o", col="black", lty=0, ylim=c(-44283020.284713246, 128795340.63605303), xlab="", ylab="")
points(factor(size, levels=size), real_time, col="black", pch="o")
lines(factor(size, levels=size), real_time, col="black", lty=1, lwd=2)
title(main="Зависимость задержки от фактора", xlab="Размер сообщения (б)", ylab="Задержка (нс)")
points(factor(size, levels=size), cpu_time, col="red", pch="X")
lines(factor(size, levels=size), cpu_time, col="red", lty=2, lwd=2)
legend("bottomright", legend=c("Время отправки (нс)", "Время отправки CPU (нс)"), col=c("black", "red"), lty=c(1, 2), pch=c("o", "X"), ncol=1)

plot(factor(size, levels=size), bytes_per_second, type="o", col="black", lty=0, ylim=c(-8082370115.802731, 16652319020.964073), xlab="", ylab="")
points(factor(size, levels=size), bytes_per_second, col="black", pch="o")
lines(factor(size, levels=size), bytes_per_second, col="black", lty=1, lwd=2)
title(main="Зависимость широты пропускания от фактора", xlab="Размер сообщения (б)", ylab="Широта пропускания (байт/сек)")
text( factor(size, levels=size), bytes_per_second, labels=bytes_per_second, cex= 0.7, pos=3)
points(factor(size, levels=size), manual_bandwidth, col="red", pch="X")
lines(factor(size, levels=size), manual_bandwidth, col="red", lty=2, lwd=2)
text( factor(size, levels=size), manual_bandwidth, labels=manual_bandwidth, cex= 0.7, pos=3)
legend("bottomright", legend=c("Широта пропускания публикующего (б/с)", "Широта пропускания принимающего (б/с)"), col=c("black", "red"), lty=c(1, 2), pch=c("o", "X"), ncol=1)

Benchmark name is “PublisherFixture/ROS_BM_Publish_method” by var=size where subs_count=2 buffer=1

#png(filename="plot.png", width = 1600, height = 900)
size <- c(1024, 4096, 16384, 65536, 262144, 1048576, 4194304, 16777216, 67108864)
real_time <- c(5157.011854205701, 5066.614075190955, 7521.461427117245, 34846.32125337281, 138466.80334453724, 1049393.0118269408, 2557254.6511730812, 22559426.36559212, 89927750.20001318)
cpu_time <- c(4074.007642896597, 4390.646898982709, 6941.257041351013, 32616.890693069163, 129852.51859758081, 998608.2619041704, 2528496.416431994, 21285161.103121914, 85783181.7124989)
bytes_per_second <- c(397220849.88300574, 1617027284.1902287, 4405431196.978784, 3823183776.5883217, 3929260681.2738633, 1999232016.0359528, 4849990870.313324, 1487469904.2389154, 1492840055.6196458)
manual_bandwidth <- c(488726486.6053093, 868839785.6372092, 6882682990.76209, 4092402725.4754357, 1104191718.8160434, 297587554.9579857, 43486142.14427169, 66693479.00302472, 39672064.81443493)
manual_latency <- c(82142198.40676616, 69236999.46569867, 35454693.13271073, 22585023.41780781, 80577364.41085295, 101937629.46190262, 596726049.9999999, 1008205188.7, 3799002010.5)
df <- data.frame("factor"=size, "Время отправки (нс)"=real_time, "Время отправки CPU (нс)"=cpu_time, "Широта пропускания публикующего (б/с)"=bytes_per_second, "Широта пропускания принимающего (б/с)"=manual_bandwidth, "Задержка передачи (нс)"=manual_latency)
plot(factor(size, levels=size), real_time, type="o", col="black", lty=0, ylim=c(-46979677.027282834, 136911501.23493892), xlab="", ylab="")
points(factor(size, levels=size), real_time, col="black", pch="o")
lines(factor(size, levels=size), real_time, col="black", lty=1, lwd=2)
title(main="Зависимость задержки от фактора", xlab="Размер сообщения (б)", ylab="Задержка (нс)")
points(factor(size, levels=size), cpu_time, col="red", pch="X")
lines(factor(size, levels=size), cpu_time, col="red", lty=2, lwd=2)
legend("bottomright", legend=c("Время отправки (нс)", "Время отправки CPU (нс)"), col=c("black", "red"), lty=c(1, 2), pch=c("o", "X"), ncol=1)

plot(factor(size, levels=size), bytes_per_second, type="o", col="black", lty=0, ylim=c(-13150109145.592049, 20072464201.168575), xlab="", ylab="")
points(factor(size, levels=size), bytes_per_second, col="black", pch="o")
lines(factor(size, levels=size), bytes_per_second, col="black", lty=1, lwd=2)
title(main="Зависимость широты пропускания от фактора", xlab="Размер сообщения (б)", ylab="Широта пропускания (байт/сек)")
text( factor(size, levels=size), bytes_per_second, labels=bytes_per_second, cex= 0.7, pos=3)
points(factor(size, levels=size), manual_bandwidth, col="red", pch="X")
lines(factor(size, levels=size), manual_bandwidth, col="red", lty=2, lwd=2)
text( factor(size, levels=size), manual_bandwidth, labels=manual_bandwidth, cex= 0.7, pos=3)
legend("bottomright", legend=c("Широта пропускания публикующего (б/с)", "Широта пропускания принимающего (б/с)"), col=c("black", "red"), lty=c(1, 2), pch=c("o", "X"), ncol=1)

Benchmark name is “PublisherFixture/ROS_BM_Publish_method” by var=size where subs_count=2 buffer=10

#png(filename="plot.png", width = 1600, height = 900)
size <- c(1024, 4096, 16384, 65536, 262144, 1048576, 4194304, 16777216, 67108864)
real_time <- c(4786.512908634228, 5010.18803186704, 9648.827123774035, 17500.153627816115, 156678.52654583377, 1062913.473846598, 2448094.834862402, 22561735.027286913, 90571704.1999992)
cpu_time <- c(3977.817551199181, 4358.697393979326, 8940.691778472941, 16762.5256312205, 146432.22351725868, 1008077.2297174223, 2410404.031687948, 21388009.081821375, 85892568.46249923)
bytes_per_second <- c(427877594.2851998, 1635137728.5418162, 3426325958.521861, 7706105140.572764, 3377772643.1434693, 1973262041.9217057, 4865094016.236982, 1487560472.1948926, 1481918626.544727)
manual_bandwidth <- c(13510473485.041466, 1189163222.6229599, 8547580529.917875, 1003249693.6337998, 3473434842.778556, 315903457.72692543, 51878344.542379335, 57474150.51280172, 34573926.6295575)
manual_latency <- c(3681929.9947898104, 69397024.38562232, 6082395.292379005, 64216843.20106669, 73459386.45098288, 102703338.59898433, 472805668.7499999, 1075517916.8, 3884474346.9)
df <- data.frame("factor"=size, "Время отправки (нс)"=real_time, "Время отправки CPU (нс)"=cpu_time, "Широта пропускания публикующего (б/с)"=bytes_per_second, "Широта пропускания принимающего (б/с)"=manual_bandwidth, "Задержка передачи (нс)"=manual_latency)
plot(factor(size, levels=size), real_time, type="o", col="black", lty=0, ylim=c(-46975034.65335734, 137550716.67090774), xlab="", ylab="")
points(factor(size, levels=size), real_time, col="black", pch="o")
lines(factor(size, levels=size), real_time, col="black", lty=1, lwd=2)
title(main="Зависимость задержки от фактора", xlab="Размер сообщения (б)", ylab="Задержка (нс)")
points(factor(size, levels=size), cpu_time, col="red", pch="X")
lines(factor(size, levels=size), cpu_time, col="red", lty=2, lwd=2)
legend("bottomright", legend=c("Время отправки (нс)", "Время отправки CPU (нс)"), col=c("black", "red"), lty=c(1, 2), pch=c("o", "X"), ncol=1)

plot(factor(size, levels=size), bytes_per_second, type="o", col="black", lty=0, ylim=c(-11949430337.10421, 25494477748.77523), xlab="", ylab="")
points(factor(size, levels=size), bytes_per_second, col="black", pch="o")
lines(factor(size, levels=size), bytes_per_second, col="black", lty=1, lwd=2)
title(main="Зависимость широты пропускания от фактора", xlab="Размер сообщения (б)", ylab="Широта пропускания (байт/сек)")
text( factor(size, levels=size), bytes_per_second, labels=bytes_per_second, cex= 0.7, pos=3)
points(factor(size, levels=size), manual_bandwidth, col="red", pch="X")
lines(factor(size, levels=size), manual_bandwidth, col="red", lty=2, lwd=2)
text( factor(size, levels=size), manual_bandwidth, labels=manual_bandwidth, cex= 0.7, pos=3)
legend("bottomright", legend=c("Широта пропускания публикующего (б/с)", "Широта пропускания принимающего (б/с)"), col=c("black", "red"), lty=c(1, 2), pch=c("o", "X"), ncol=1)

Benchmark name is “PublisherFixture/ROS_BM_Publish_method” by var=size where subs_count=2 buffer=100

#png(filename="plot.png", width = 1600, height = 900)
size <- c(1024, 4096, 16384, 65536, 262144, 1048576, 4194304, 16777216, 67108864)
real_time <- c(4788.4441863204265, 4992.848741784826, 9307.297751659746, 28008.43602805565, 118446.11124035002, 1045177.2451610618, 2315141.7616982264, 22355699.803196214, 88680996.94998363)
cpu_time <- c(3942.1589292166345, 4342.987223008087, 8598.71304644371, 26223.890796388507, 112039.72276923378, 977938.2818736115, 2273895.2883129334, 21274983.38709595, 86191063.26250406)
bytes_per_second <- c(427712338.78835094, 1640815507.0075707, 3569727017.760775, 5101436170.133032, 4632655800.211837, 2008952571.5023131, 5910106222.714949, 1501298809.8137298, 1514139480.1089492)
manual_bandwidth <- c(11753311273.55764, 1051863292.1080315, 7020589668.383814, 7171677046.238512, 1893473696.7061825, 404496438.7546527, 46890340.817584045, 51800864.92281709, 34611524.52859531)
manual_latency <- c(5016327.149989426, 77179944.7658565, 13708409.237381566, 35890701.40487538, 83045250.55993205, 88118620.99615079, 342137895.0, 1129658543.0, 3880524864.1)
df <- data.frame("factor"=size, "Время отправки (нс)"=real_time, "Время отправки CPU (нс)"=cpu_time, "Широта пропускания публикующего (б/с)"=bytes_per_second, "Широта пропускания принимающего (б/с)"=manual_bandwidth, "Задержка передачи (нс)"=manual_latency)
plot(factor(size, levels=size), real_time, type="o", col="black", lty=0, ylim=c(-47093286.67010858, 135778225.77902144), xlab="", ylab="")
points(factor(size, levels=size), real_time, col="black", pch="o")
lines(factor(size, levels=size), real_time, col="black", lty=1, lwd=2)
title(main="Зависимость задержки от фактора", xlab="Размер сообщения (б)", ylab="Задержка (нс)")
points(factor(size, levels=size), cpu_time, col="red", pch="X")
lines(factor(size, levels=size), cpu_time, col="red", lty=2, lwd=2)
legend("bottomright", legend=c("Время отправки (нс)", "Время отправки CPU (нс)"), col=c("black", "red"), lty=c(1, 2), pch=c("o", "X"), ncol=1)

plot(factor(size, levels=size), bytes_per_second, type="o", col="black", lty=0, ylim=c(-15192805214.279858, 26980728012.366093), xlab="", ylab="")
points(factor(size, levels=size), bytes_per_second, col="black", pch="o")
lines(factor(size, levels=size), bytes_per_second, col="black", lty=1, lwd=2)
title(main="Зависимость широты пропускания от фактора", xlab="Размер сообщения (б)", ylab="Широта пропускания (байт/сек)")
text( factor(size, levels=size), bytes_per_second, labels=bytes_per_second, cex= 0.7, pos=3)
points(factor(size, levels=size), manual_bandwidth, col="red", pch="X")
lines(factor(size, levels=size), manual_bandwidth, col="red", lty=2, lwd=2)
text( factor(size, levels=size), manual_bandwidth, labels=manual_bandwidth, cex= 0.7, pos=3)
legend("bottomright", legend=c("Широта пропускания публикующего (б/с)", "Широта пропускания принимающего (б/с)"), col=c("black", "red"), lty=c(1, 2), pch=c("o", "X"), ncol=1)

Benchmark name is “PublisherFixture/ROS_BM_Publish_method” by var=size where subs_count=2 buffer=1000

#png(filename="plot.png", width = 1600, height = 900)
size <- c(1024, 4096, 16384, 65536, 262144, 1048576, 4194304, 16777216, 67108864)
real_time <- c(4785.349781783731, 5008.709241208635, 8786.187739685674, 42374.0165652213, 116784.93429238015, 1043647.9576920314, 2359972.559685654, 22414016.296895057, 89716667.31254117)
cpu_time <- c(3949.1776102545314, 4355.563179992146, 8123.481326494989, 39491.78780987342, 110091.70791835929, 976763.3032344186, 2311370.5142863803, 21266647.921870433, 85706402.67500095)
bytes_per_second <- c(427979202.6862031, 1635620657.844274, 3791193511.2788916, 3146917715.8547606, 6262394445.192435, 2011586122.5647187, 5012215604.68105, 1497391531.0611567, 1496490513.9038959)
manual_bandwidth <- c(11971461234.445177, 769163817.824446, 6562330665.497423, 6653376706.351194, 2105065632.068996, 555374458.9687614, 46795938.886254385, 50552285.35404814, 34607090.33394261)
manual_latency <- c(4393799.865931442, 77771458.24521479, 8357396.402100799, 9491419.226514764, 69250492.06501743, 82358254.74070504, 421625248.225, 992827572.75, 3880976503.3)
df <- data.frame("factor"=size, "Время отправки (нс)"=real_time, "Время отправки CPU (нс)"=cpu_time, "Широта пропускания публикующего (б/с)"=bytes_per_second, "Широта пропускания принимающего (б/с)"=manual_bandwidth, "Задержка передачи (нс)"=manual_latency)
plot(factor(size, levels=size), real_time, type="o", col="black", lty=0, ylim=c(-47235606.185731515, 136956222.67588294), xlab="", ylab="")
points(factor(size, levels=size), real_time, col="black", pch="o")
lines(factor(size, levels=size), real_time, col="black", lty=1, lwd=2)
title(main="Зависимость задержки от фактора", xlab="Размер сообщения (б)", ylab="Задержка (нс)")
points(factor(size, levels=size), cpu_time, col="red", pch="X")
lines(factor(size, levels=size), cpu_time, col="red", lty=2, lwd=2)
legend("bottomright", legend=c("Время отправки (нс)", "Время отправки CPU (нс)"), col=c("black", "red"), lty=c(1, 2), pch=c("o", "X"), ncol=1)

plot(factor(size, levels=size), bytes_per_second, type="o", col="black", lty=0, ylim=c(-11044056623.530079, 23050124948.309196), xlab="", ylab="")
points(factor(size, levels=size), bytes_per_second, col="black", pch="o")
lines(factor(size, levels=size), bytes_per_second, col="black", lty=1, lwd=2)
title(main="Зависимость широты пропускания от фактора", xlab="Размер сообщения (б)", ylab="Широта пропускания (байт/сек)")
text( factor(size, levels=size), bytes_per_second, labels=bytes_per_second, cex= 0.7, pos=3)
points(factor(size, levels=size), manual_bandwidth, col="red", pch="X")
lines(factor(size, levels=size), manual_bandwidth, col="red", lty=2, lwd=2)
text( factor(size, levels=size), manual_bandwidth, labels=manual_bandwidth, cex= 0.7, pos=3)
legend("bottomright", legend=c("Широта пропускания публикующего (б/с)", "Широта пропускания принимающего (б/с)"), col=c("black", "red"), lty=c(1, 2), pch=c("o", "X"), ncol=1)

Benchmark name is “PublisherFixture/ROS_BM_Publish_method” by var=size where subs_count=2 buffer=10000

#png(filename="plot.png", width = 1600, height = 900)
size <- c(1024, 4096, 16384, 65536, 262144, 1048576, 4194304, 16777216, 67108864)
real_time <- c(4820.713313170985, 4968.031603459658, 8932.244906434218, 28791.789275937354, 118492.05242499604, 1056295.8743406371, 2039001.39545636, 22575119.67813741, 89915839.62508684)
cpu_time <- c(3975.039859758196, 4330.63404212249, 8256.99268562074, 27099.29849543299, 110418.11147389459, 1001880.9252224505, 2020847.947879585, 21325079.599998984, 86114938.05000237)
bytes_per_second <- c(425490283.8058814, 1649071796.7249732, 3687889300.5797815, 4673009781.780072, 5106005358.142822, 1985621035.2700417, 6158570988.034955, 1486570954.332946, 1493074867.8146243)
manual_bandwidth <- c(7387770172.393695, 1089872499.312002, 8256254659.259003, 4783599694.026499, 1237491098.9358497, 277874947.56378603, 52337303.617246225, 62585798.89146529, 27468889.404516257)
manual_latency <- c(13871864.109881664, 76338393.0376416, 10419793.151907107, 33457553.783326417, 77199931.33760805, 101509351.58627497, 443514995.05, 1032681598.45, 3127171751.1)
df <- data.frame("factor"=size, "Время отправки (нс)"=real_time, "Время отправки CPU (нс)"=cpu_time, "Широта пропускания публикующего (б/с)"=bytes_per_second, "Широта пропускания принимающего (б/с)"=manual_bandwidth, "Задержка передачи (нс)"=manual_latency)
plot(factor(size, levels=size), real_time, type="o", col="black", lty=0, ylim=c(-47080006.86325635, 136999821.52820295), xlab="", ylab="")
points(factor(size, levels=size), real_time, col="black", pch="o")
lines(factor(size, levels=size), real_time, col="black", lty=1, lwd=2)
title(main="Зависимость задержки от фактора", xlab="Размер сообщения (б)", ylab="Задержка (нс)")
points(factor(size, levels=size), cpu_time, col="red", pch="X")
lines(factor(size, levels=size), cpu_time, col="red", lty=2, lwd=2)
legend("bottomright", legend=c("Время отправки (нс)", "Время отправки CPU (нс)"), col=c("black", "red"), lty=c(1, 2), pch=c("o", "X"), ncol=1)

plot(factor(size, levels=size), bytes_per_second, type="o", col="black", lty=0, ylim=c(-11171216714.301285, 19454940262.9648), xlab="", ylab="")
points(factor(size, levels=size), bytes_per_second, col="black", pch="o")
lines(factor(size, levels=size), bytes_per_second, col="black", lty=1, lwd=2)
title(main="Зависимость широты пропускания от фактора", xlab="Размер сообщения (б)", ylab="Широта пропускания (байт/сек)")
text( factor(size, levels=size), bytes_per_second, labels=bytes_per_second, cex= 0.7, pos=3)
points(factor(size, levels=size), manual_bandwidth, col="red", pch="X")
lines(factor(size, levels=size), manual_bandwidth, col="red", lty=2, lwd=2)
text( factor(size, levels=size), manual_bandwidth, labels=manual_bandwidth, cex= 0.7, pos=3)
legend("bottomright", legend=c("Широта пропускания публикующего (б/с)", "Широта пропускания принимающего (б/с)"), col=c("black", "red"), lty=c(1, 2), pch=c("o", "X"), ncol=1)

Benchmark name is “PublisherFixture/ROS_BM_Publish_method” by var=size where subs_count=4 buffer=1

#png(filename="plot.png", width = 1600, height = 900)
size <- c(1024, 4096, 16384, 65536, 262144, 1048576, 4194304, 16777216, 67108864)
real_time <- c(4684.410036701205, 5346.713790906761, 12739.164268983752, 29944.50241370626, 86679.54204052503, 1019453.1587962955, 2207735.459279661, 23292156.30967273, 93498160.96246286)
cpu_time <- c(3339.426264617111, 4312.555429542455, 11534.677806046744, 28100.971902250858, 82794.52101032724, 946961.6993996624, 2146591.974364406, 21914477.358061578, 88778417.11252189)
bytes_per_second <- c(874634945.652821, 3064724132.7861276, 5240856404.250961, 9217878181.176826, 12849323610.198, 4126594766.9789224, 9073821024.198309, 2881641092.722139, 2872424553.5251665)
manual_bandwidth <- c(33317737593.986713, 2329416068.3462152, 13475766682.934181, 14011257059.91748, 2259050407.348436, 1611068316.3186483, 107360186.24234459, 133697911.92292611, 76775254.21171837)
manual_latency <- c(3587458.8356091543, 69984912.93569992, 3373828.0174958035, 33114581.10933975, 86140909.76873703, 82817313.55019698, 619456585.3566667, 1005167778.25, 3926255453.55)
df <- data.frame("factor"=size, "Время отправки (нс)"=real_time, "Время отправки CPU (нс)"=cpu_time, "Широта пропускания публикующего (б/с)"=bytes_per_second, "Широта пропускания принимающего (б/с)"=manual_bandwidth, "Задержка передачи (нс)"=manual_latency)
plot(factor(size, levels=size), real_time, type="o", col="black", lty=0, ylim=c(-49849268.202999644, 143350768.5917271), xlab="", ylab="")
points(factor(size, levels=size), real_time, col="black", pch="o")
lines(factor(size, levels=size), real_time, col="black", lty=1, lwd=2)
title(main="Зависимость задержки от фактора", xlab="Размер сообщения (б)", ylab="Задержка (нс)")
points(factor(size, levels=size), cpu_time, col="red", pch="X")
lines(factor(size, levels=size), cpu_time, col="red", lty=2, lwd=2)
legend("bottomright", legend=c("Время отправки (нс)", "Время отправки CPU (нс)"), col=c("black", "red"), lty=c(1, 2), pch=c("o", "X"), ncol=1)

plot(factor(size, levels=size), bytes_per_second, type="o", col="black", lty=0, ylim=c(-34437684345.71974, 67832197193.91817), xlab="", ylab="")
points(factor(size, levels=size), bytes_per_second, col="black", pch="o")
lines(factor(size, levels=size), bytes_per_second, col="black", lty=1, lwd=2)
title(main="Зависимость широты пропускания от фактора", xlab="Размер сообщения (б)", ylab="Широта пропускания (байт/сек)")
text( factor(size, levels=size), bytes_per_second, labels=bytes_per_second, cex= 0.7, pos=3)
points(factor(size, levels=size), manual_bandwidth, col="red", pch="X")
lines(factor(size, levels=size), manual_bandwidth, col="red", lty=2, lwd=2)
text( factor(size, levels=size), manual_bandwidth, labels=manual_bandwidth, cex= 0.7, pos=3)
legend("bottomright", legend=c("Широта пропускания публикующего (б/с)", "Широта пропускания принимающего (б/с)"), col=c("black", "red"), lty=c(1, 2), pch=c("o", "X"), ncol=1)

Benchmark name is “PublisherFixture/ROS_BM_Publish_method” by var=size where subs_count=4 buffer=10

#png(filename="plot.png", width = 1600, height = 900)
size <- c(1024, 4096, 16384, 65536, 262144, 1048576, 4194304, 16777216, 67108864)
real_time <- c(4605.697632950371, 5367.284222920496, 8369.486783418668, 27571.602306367615, 210490.30252709132, 1053547.9085778226, 2015943.2467647314, 23504962.296752755, 91232388.98746423)
cpu_time <- c(3347.2170040059764, 4326.7471633898185, 7545.14963636342, 25937.902090064883, 193232.61614858796, 983041.5359255284, 1980392.9275694578, 22159873.264530275, 87516438.4750036)
bytes_per_second <- c(889338766.6675043, 3053003432.596627, 7923108962.661034, 10078705939.816374, 5124425685.3186455, 3982054647.796869, 10838747136.070347, 2856000457.834505, 2944440941.3977957)
manual_bandwidth <- c(38957175762.18716, 2381763236.2732363, 11314477975.625984, 5530105923.034509, 3275857905.639853, 903666628.6355705, 112091357.4218053, 133653012.92550774, 67084073.830885425)
manual_latency <- c(2653355.2797045363, 71100658.07463613, 20053693.589383326, 42154147.876311064, 41921718.62008665, 90803610.58428074, 435758229.1333333, 1005367566.55, 4003217457.1)
df <- data.frame("factor"=size, "Время отправки (нс)"=real_time, "Время отправки CPU (нс)"=cpu_time, "Широта пропускания публикующего (б/с)"=bytes_per_second, "Широта пропускания принимающего (б/с)"=manual_bandwidth, "Задержка передачи (нс)"=manual_latency)
plot(factor(size, levels=size), real_time, type="o", col="black", lty=0, ylim=c(-49244275.294164404, 140480011.49863264), xlab="", ylab="")
points(factor(size, levels=size), real_time, col="black", pch="o")
lines(factor(size, levels=size), real_time, col="black", lty=1, lwd=2)
title(main="Зависимость задержки от фактора", xlab="Размер сообщения (б)", ylab="Задержка (нс)")
points(factor(size, levels=size), cpu_time, col="red", pch="X")
lines(factor(size, levels=size), cpu_time, col="red", lty=2, lwd=2)
legend("bottomright", legend=c("Время отправки (нс)", "Время отправки CPU (нс)"), col=c("black", "red"), lty=c(1, 2), pch=c("o", "X"), ncol=1)

plot(factor(size, levels=size), bytes_per_second, type="o", col="black", lty=0, ylim=c(-33321389107.943455, 72345648943.9615), xlab="", ylab="")
points(factor(size, levels=size), bytes_per_second, col="black", pch="o")
lines(factor(size, levels=size), bytes_per_second, col="black", lty=1, lwd=2)
title(main="Зависимость широты пропускания от фактора", xlab="Размер сообщения (б)", ylab="Широта пропускания (байт/сек)")
text( factor(size, levels=size), bytes_per_second, labels=bytes_per_second, cex= 0.7, pos=3)
points(factor(size, levels=size), manual_bandwidth, col="red", pch="X")
lines(factor(size, levels=size), manual_bandwidth, col="red", lty=2, lwd=2)
text( factor(size, levels=size), manual_bandwidth, labels=manual_bandwidth, cex= 0.7, pos=3)
legend("bottomright", legend=c("Широта пропускания публикующего (б/с)", "Широта пропускания принимающего (б/с)"), col=c("black", "red"), lty=c(1, 2), pch=c("o", "X"), ncol=1)

Benchmark name is “PublisherFixture/ROS_BM_Publish_method” by var=size where subs_count=4 buffer=100

#png(filename="plot.png", width = 1600, height = 900)
size <- c(1024, 4096, 16384, 65536, 262144, 1048576, 4194304, 16777216, 67108864)
real_time <- c(4624.482520685689, 5399.78996214403, 9490.150547117206, 34644.16481699764, 134070.25446016068, 1008150.0168363571, 1995241.8501838427, 23068276.403340254, 92551044.3624944)
cpu_time <- c(3307.0349335376313, 4343.02291016358, 8535.646722518413, 32319.58201020346, 124878.06475391709, 946257.5054398484, 1960510.2177928023, 21873380.620002083, 88371835.92498264)
bytes_per_second <- c(885769097.0603113, 3034455990.8642945, 7128254019.550135, 7833252639.021375, 9851014823.972012, 4191437308.220475, 9565382380.90919, 2909598738.8389, 2902150669.535243)
manual_bandwidth <- c(27310638125.28106, 2033944234.4771824, 15768120639.365692, 9560131902.1992, 5994457919.501843, 1090334610.9008038, 147367059.01183873, 130036593.07107392, 66992589.310907885)
manual_latency <- c(6639831.718454286, 64148483.550389096, 18481973.565961625, 19961973.998794958, 71624033.75718684, 91138186.48844936, 443972059.35999995, 1032974701.15, 4008701339.4)
df <- data.frame("factor"=size, "Время отправки (нс)"=real_time, "Время отправки CPU (нс)"=cpu_time, "Широта пропускания публикующего (б/с)"=bytes_per_second, "Широта пропускания принимающего (б/с)"=manual_bandwidth, "Задержка передачи (нс)"=manual_latency)
plot(factor(size, levels=size), real_time, type="o", col="black", lty=0, ylim=c(-49649462.677905686, 142203814.07533363), xlab="", ylab="")
points(factor(size, levels=size), real_time, col="black", pch="o")
lines(factor(size, levels=size), real_time, col="black", lty=1, lwd=2)
title(main="Зависимость задержки от фактора", xlab="Размер сообщения (б)", ylab="Задержка (нс)")
points(factor(size, levels=size), cpu_time, col="red", pch="X")
lines(factor(size, levels=size), cpu_time, col="red", lty=2, lwd=2)
legend("bottomright", legend=c("Время отправки (нс)", "Время отправки CPU (нс)"), col=c("black", "red"), lty=c(1, 2), pch=c("o", "X"), ncol=1)

plot(factor(size, levels=size), bytes_per_second, type="o", col="black", lty=0, ylim=c(-31915842726.727684, 59293473441.31965), xlab="", ylab="")
points(factor(size, levels=size), bytes_per_second, col="black", pch="o")
lines(factor(size, levels=size), bytes_per_second, col="black", lty=1, lwd=2)
title(main="Зависимость широты пропускания от фактора", xlab="Размер сообщения (б)", ylab="Широта пропускания (байт/сек)")
text( factor(size, levels=size), bytes_per_second, labels=bytes_per_second, cex= 0.7, pos=3)
points(factor(size, levels=size), manual_bandwidth, col="red", pch="X")
lines(factor(size, levels=size), manual_bandwidth, col="red", lty=2, lwd=2)
text( factor(size, levels=size), manual_bandwidth, labels=manual_bandwidth, cex= 0.7, pos=3)
legend("bottomright", legend=c("Широта пропускания публикующего (б/с)", "Широта пропускания принимающего (б/с)"), col=c("black", "red"), lty=c(1, 2), pch=c("o", "X"), ncol=1)

Benchmark name is “PublisherFixture/ROS_BM_Publish_method” by var=size where subs_count=4 buffer=1000

#png(filename="plot.png", width = 1600, height = 900)
size <- c(1024, 4096, 16384, 65536, 262144, 1048576, 4194304, 16777216, 67108864)
real_time <- c(4712.889624609076, 5361.902088942925, 10752.269587540362, 36526.00896665214, 167898.01963332348, 1065363.2333856323, 1862110.5648453697, 23347286.599988975, 92941189.26244438)
cpu_time <- c(3370.339144370778, 4306.291444705461, 9725.664769400386, 34106.24228974003, 155198.68818133732, 1011206.7681832307, 1807315.7705451879, 22050606.196670894, 88493378.37500286)
bytes_per_second <- c(869127377.0770099, 3055941645.1282587, 6292109405.968262, 7254261781.212016, 6435647074.575093, 3940250242.7986403, 11731203931.272608, 2874616568.07146, 2888397199.7083015)
manual_bandwidth <- c(23581343245.885048, 2289535860.949351, 20973582784.367477, 11418274712.35957, 3571684890.2738266, 487172300.56533176, 180829248.2683262, 124018878.37218018, 67168469.40286735)
manual_latency <- c(6253900.006806096, 71400029.05294092, 7365034.737198986, 16673952.391487712, 74279493.43260616, 139895687.1297222, 365490733.16833335, 1032704555.4, 3998641182.8)
df <- data.frame("factor"=size, "Время отправки (нс)"=real_time, "Время отправки CPU (нс)"=cpu_time, "Широта пропускания публикующего (б/с)"=bytes_per_second, "Широта пропускания принимающего (б/с)"=manual_bandwidth, "Задержка передачи (нс)"=manual_latency)
plot(factor(size, levels=size), real_time, type="o", col="black", lty=0, ylim=c(-48056106.46102382, 141000666.06261256), xlab="", ylab="")
points(factor(size, levels=size), real_time, col="black", pch="o")
lines(factor(size, levels=size), real_time, col="black", lty=1, lwd=2)
title(main="Зависимость задержки от фактора", xlab="Размер сообщения (б)", ylab="Задержка (нс)")
points(factor(size, levels=size), cpu_time, col="red", pch="X")
lines(factor(size, levels=size), cpu_time, col="red", lty=2, lwd=2)
legend("bottomright", legend=c("Время отправки (нс)", "Время отправки CPU (нс)"), col=c("black", "red"), lty=c(1, 2), pch=c("o", "X"), ncol=1)

plot(factor(size, levels=size), bytes_per_second, type="o", col="black", lty=0, ylim=c(-25980251125.52136, 49628762840.80927), xlab="", ylab="")
points(factor(size, levels=size), bytes_per_second, col="black", pch="o")
lines(factor(size, levels=size), bytes_per_second, col="black", lty=1, lwd=2)
title(main="Зависимость широты пропускания от фактора", xlab="Размер сообщения (б)", ylab="Широта пропускания (байт/сек)")
text( factor(size, levels=size), bytes_per_second, labels=bytes_per_second, cex= 0.7, pos=3)
points(factor(size, levels=size), manual_bandwidth, col="red", pch="X")
lines(factor(size, levels=size), manual_bandwidth, col="red", lty=2, lwd=2)
text( factor(size, levels=size), manual_bandwidth, labels=manual_bandwidth, cex= 0.7, pos=3)
legend("bottomright", legend=c("Широта пропускания публикующего (б/с)", "Широта пропускания принимающего (б/с)"), col=c("black", "red"), lty=c(1, 2), pch=c("o", "X"), ncol=1)

Benchmark name is “PublisherFixture/ROS_BM_Publish_method” by var=size where subs_count=4 buffer=10000

#png(filename="plot.png", width = 1600, height = 900)
size <- c(1024, 4096, 16384, 65536, 262144, 1048576, 4194304, 16777216, 67108864)
real_time <- c(4587.953994373003, 5370.790820216232, 9245.790448701935, 27265.91673362119, 149781.32933947368, 1057543.882882535, 1396115.5897024714, 23305184.95172296, 93057628.11248997)
cpu_time <- c(3237.9827143256225, 4327.178122762954, 8384.418419042242, 25648.98542756456, 138081.84668269302, 1005631.0280327635, 1368306.8562658033, 21952144.58275696, 87969822.2874964)
bytes_per_second <- c(892897826.9535488, 3050739653.3870015, 7115003107.011942, 10482922214.487345, 8588301194.865343, 3967768007.405999, 12678530426.041998, 2880529515.95339, 2884831442.8780107)
manual_bandwidth <- c(16273678924.709589, 2156300520.061728, 34989820869.9505, 7309314599.778905, 1755849440.5081794, 530392484.89424354, 251041516.35877603, 104369022.20619102, 53351514.60043373)
manual_latency <- c(20032105.41607633, 64072438.99136543, 2647378.1340222927, 37669459.2848752, 75645148.86241046, 92438736.00555554, 269597561.4666667, 1106952711.4, 3220132418.9)
df <- data.frame("factor"=size, "Время отправки (нс)"=real_time, "Время отправки CPU (нс)"=cpu_time, "Широта пропускания публикующего (б/с)"=bytes_per_second, "Широта пропускания принимающего (б/с)"=manual_bandwidth, "Задержка передачи (нс)"=manual_latency)
plot(factor(size, levels=size), real_time, type="o", col="black", lty=0, ylim=c(-47737272.28056138, 140798138.37576568), xlab="", ylab="")
points(factor(size, levels=size), real_time, col="black", pch="o")
lines(factor(size, levels=size), real_time, col="black", lty=1, lwd=2)
title(main="Зависимость задержки от фактора", xlab="Размер сообщения (б)", ylab="Задержка (нс)")
points(factor(size, levels=size), cpu_time, col="red", pch="X")
lines(factor(size, levels=size), cpu_time, col="red", lty=2, lwd=2)
legend("bottomright", legend=c("Время отправки (нс)", "Время отправки CPU (нс)"), col=c("black", "red"), lty=c(1, 2), pch=c("o", "X"), ncol=1)

plot(factor(size, levels=size), bytes_per_second, type="o", col="black", lty=0, ylim=c(-34753827349.15834, 69796999733.70927), xlab="", ylab="")
points(factor(size, levels=size), bytes_per_second, col="black", pch="o")
lines(factor(size, levels=size), bytes_per_second, col="black", lty=1, lwd=2)
title(main="Зависимость широты пропускания от фактора", xlab="Размер сообщения (б)", ylab="Широта пропускания (байт/сек)")
text( factor(size, levels=size), bytes_per_second, labels=bytes_per_second, cex= 0.7, pos=3)
points(factor(size, levels=size), manual_bandwidth, col="red", pch="X")
lines(factor(size, levels=size), manual_bandwidth, col="red", lty=2, lwd=2)
text( factor(size, levels=size), manual_bandwidth, labels=manual_bandwidth, cex= 0.7, pos=3)
legend("bottomright", legend=c("Широта пропускания публикующего (б/с)", "Широта пропускания принимающего (б/с)"), col=c("black", "red"), lty=c(1, 2), pch=c("o", "X"), ncol=1)

Benchmark name is “PublisherFixture/ROS_BM_Publish_method” by var=size where subs_count=8 buffer=1

#png(filename="plot.png", width = 1600, height = 900)
size <- c(1024, 4096, 16384, 65536, 262144, 1048576, 4194304, 16777216, 67108864)
real_time <- c(6249.40646490663, 5298.868434206353, 9692.959681376462, 26357.95210569732, 109822.98327717185, 510811.6901620716, 1554646.5007241913, 26143153.374057334, 120207000.35001254)
cpu_time <- c(3039.782576182089, 3282.7024012936004, 8444.946042044916, 13736.928344962123, 68027.28275471374, 348529.2104119652, 1124270.9667290214, 22511168.3370364, 94906323.32498308)
bytes_per_second <- c(1332488547.6901639, 6248669858.39148, 13571873267.218204, 19933719040.95071, 23491295832.524227, 21468127100.79583, 22719089450.150375, 5182736990.753264, 4522665854.849938)
manual_bandwidth <- c(63697450779.432655, 29743578193.40341, 28856689590.871117, 3177106811.4947248, 3779829285.59348, 2698813036.744806, 754037456.8582256, 170878241.28796715, 129915114.14094861)
manual_latency <- c(2062459.5037345835, 7468308.709027636, 4243554.973943848, 77158951.52757393, 118490523.2363313, 175578147.78588906, 346825505.2583333, 1256933917.45, 4631043895.9)
df <- data.frame("factor"=size, "Время отправки (нс)"=real_time, "Время отправки CPU (нс)"=cpu_time, "Широта пропускания публикующего (б/с)"=bytes_per_second, "Широта пропускания принимающего (б/с)"=manual_bandwidth, "Задержка передачи (нс)"=manual_latency)
plot(factor(size, levels=size), real_time, type="o", col="black", lty=0, ylim=c(-79789299.48007293, 199999339.61266166), xlab="", ylab="")
points(factor(size, levels=size), real_time, col="black", pch="o")
lines(factor(size, levels=size), real_time, col="black", lty=1, lwd=2)
title(main="Зависимость задержки от фактора", xlab="Размер сообщения (б)", ylab="Задержка (нс)")
points(factor(size, levels=size), cpu_time, col="red", pch="X")
lines(factor(size, levels=size), cpu_time, col="red", lty=2, lwd=2)
legend("bottomright", legend=c("Время отправки (нс)", "Время отправки CPU (нс)"), col=c("black", "red"), lty=c(1, 2), pch=c("o", "X"), ncol=1)

plot(factor(size, levels=size), bytes_per_second, type="o", col="black", lty=0, ylim=c(-53840380225.36757, 117667746118.94116), xlab="", ylab="")
points(factor(size, levels=size), bytes_per_second, col="black", pch="o")
lines(factor(size, levels=size), bytes_per_second, col="black", lty=1, lwd=2)
title(main="Зависимость широты пропускания от фактора", xlab="Размер сообщения (б)", ylab="Широта пропускания (байт/сек)")
text( factor(size, levels=size), bytes_per_second, labels=bytes_per_second, cex= 0.7, pos=3)
points(factor(size, levels=size), manual_bandwidth, col="red", pch="X")
lines(factor(size, levels=size), manual_bandwidth, col="red", lty=2, lwd=2)
text( factor(size, levels=size), manual_bandwidth, labels=manual_bandwidth, cex= 0.7, pos=3)
legend("bottomright", legend=c("Широта пропускания публикующего (б/с)", "Широта пропускания принимающего (б/с)"), col=c("black", "red"), lty=c(1, 2), pch=c("o", "X"), ncol=1)

Benchmark name is “PublisherFixture/ROS_BM_Publish_method” by var=size where subs_count=8 buffer=10

#png(filename="plot.png", width = 1600, height = 900)
size <- c(1024, 4096, 16384, 65536, 262144, 1048576, 4194304, 16777216, 67108864)
real_time <- c(6107.915192913591, 5084.288325373656, 9742.235739851585, 35193.897385136064, 110800.22258164443, 762440.1167911757, 1321079.7203019361, 26556223.67240634, 135832183.7201038)
cpu_time <- c(3005.5745473444526, 3203.3299574278667, 8367.012479025318, 25703.564367585266, 68091.55215840395, 510935.05517043284, 1049516.1158216244, 22748359.231025398, 96267461.45996548)
bytes_per_second <- c(1356733573.9255395, 6520187621.122169, 13546676451.435375, 15318412942.194447, 24476482502.333714, 11853508247.476137, 26569579728.799263, 5096349623.214842, 4054744034.389286)
manual_bandwidth <- c(54151966031.10595, 35891918134.00308, 30231073262.137306, 11175450356.203901, 2794785200.495612, 1940537714.0710998, 472345704.5246213, 197037880.00146163, 110213680.28714296)
manual_latency <- c(2086203.3690450503, 6915341.520207157, 5674405.101053295, 53135941.73016544, 119467162.81183815, 135640486.32835308, 339775773.6261905, 1190112701.95, 4875863732.6)
df <- data.frame("factor"=size, "Время отправки (нс)"=real_time, "Время отправки CPU (нс)"=cpu_time, "Широта пропускания публикующего (б/с)"=bytes_per_second, "Широта пропускания принимающего (б/с)"=manual_bandwidth, "Задержка передачи (нс)"=manual_latency)
plot(factor(size, levels=size), real_time, type="o", col="black", lty=0, ylim=c(-98867508.04983212, 234702697.34448326), xlab="", ylab="")
points(factor(size, levels=size), real_time, col="black", pch="o")
lines(factor(size, levels=size), real_time, col="black", lty=1, lwd=2)
title(main="Зависимость задержки от фактора", xlab="Размер сообщения (б)", ylab="Задержка (нс)")
points(factor(size, levels=size), cpu_time, col="red", pch="X")
lines(factor(size, levels=size), cpu_time, col="red", lty=2, lwd=2)
legend("bottomright", legend=c("Время отправки (нс)", "Время отправки CPU (нс)"), col=c("black", "red"), lty=c(1, 2), pch=c("o", "X"), ncol=1)

plot(factor(size, levels=size), bytes_per_second, type="o", col="black", lty=0, ylim=c(-57678975893.42844, 111941155604.82153), xlab="", ylab="")
points(factor(size, levels=size), bytes_per_second, col="black", pch="o")
lines(factor(size, levels=size), bytes_per_second, col="black", lty=1, lwd=2)
title(main="Зависимость широты пропускания от фактора", xlab="Размер сообщения (б)", ylab="Широта пропускания (байт/сек)")
text( factor(size, levels=size), bytes_per_second, labels=bytes_per_second, cex= 0.7, pos=3)
points(factor(size, levels=size), manual_bandwidth, col="red", pch="X")
lines(factor(size, levels=size), manual_bandwidth, col="red", lty=2, lwd=2)
text( factor(size, levels=size), manual_bandwidth, labels=manual_bandwidth, cex= 0.7, pos=3)
legend("bottomright", legend=c("Широта пропускания публикующего (б/с)", "Широта пропускания принимающего (б/с)"), col=c("black", "red"), lty=c(1, 2), pch=c("o", "X"), ncol=1)

Benchmark name is “PublisherFixture/ROS_BM_Publish_method” by var=size where subs_count=8 buffer=100

#png(filename="plot.png", width = 1600, height = 900)
size <- c(1024, 4096, 16384, 65536, 262144, 1048576, 4194304, 16777216, 67108864)
real_time <- c(5992.174665681887, 5359.818269381755, 9684.345799853301, 32024.28410567216, 260218.0751775884, 911047.9387184575, 1115102.688853146, 25119723.291980334, 122985828.25716428)
cpu_time <- c(3013.767389001032, 3295.026563652607, 8462.439291709787, 22425.825988437267, 125199.27996564968, 528270.1555309125, 952194.2029372273, 22583206.471997075, 94697308.01428925)
bytes_per_second <- c(1376222131.676145, 6252563254.584262, 13570170488.942522, 17007940188.724356, 8093676400.117966, 10127067200.823347, 30131409511.12666, 5360592562.3836975, 4432288992.212332)
manual_bandwidth <- c(40397784930.94996, 22344468241.77512, 37944143944.3015, 6678025224.872855, 1879229365.4653416, 994764779.880153, 380410481.8633764, 156218973.88218027, 114933284.83632219)
manual_latency <- c(2136194.208640861, 10212650.896962786, 4025887.318404039, 63351209.15346719, 122014240.95323467, 153970209.6454524, 456539274.82666665, 1341391983.25, 4698611895.5)
df <- data.frame("factor"=size, "Время отправки (нс)"=real_time, "Время отправки CPU (нс)"=cpu_time, "Широта пропускания публикующего (б/с)"=bytes_per_second, "Широта пропускания принимающего (б/с)"=manual_bandwidth, "Задержка передачи (нс)"=manual_latency)
plot(factor(size, levels=size), real_time, type="o", col="black", lty=0, ylim=c(-84602547.6563937, 207591389.68094698), xlab="", ylab="")
points(factor(size, levels=size), real_time, col="black", pch="o")
lines(factor(size, levels=size), real_time, col="black", lty=1, lwd=2)
title(main="Зависимость задержки от фактора", xlab="Размер сообщения (б)", ylab="Задержка (нс)")
points(factor(size, levels=size), cpu_time, col="red", pch="X")
lines(factor(size, levels=size), cpu_time, col="red", lty=2, lwd=2)
legend("bottomright", legend=c("Время отправки (нс)", "Время отправки CPU (нс)"), col=c("black", "red"), lty=c(1, 2), pch=c("o", "X"), ncol=1)

plot(factor(size, levels=size), bytes_per_second, type="o", col="black", lty=0, ylim=c(-36415497382.52037, 76928215598.30664), xlab="", ylab="")
points(factor(size, levels=size), bytes_per_second, col="black", pch="o")
lines(factor(size, levels=size), bytes_per_second, col="black", lty=1, lwd=2)
title(main="Зависимость широты пропускания от фактора", xlab="Размер сообщения (б)", ylab="Широта пропускания (байт/сек)")
text( factor(size, levels=size), bytes_per_second, labels=bytes_per_second, cex= 0.7, pos=3)
points(factor(size, levels=size), manual_bandwidth, col="red", pch="X")
lines(factor(size, levels=size), manual_bandwidth, col="red", lty=2, lwd=2)
text( factor(size, levels=size), manual_bandwidth, labels=manual_bandwidth, cex= 0.7, pos=3)
legend("bottomright", legend=c("Широта пропускания публикующего (б/с)", "Широта пропускания принимающего (б/с)"), col=c("black", "red"), lty=c(1, 2), pch=c("o", "X"), ncol=1)

Benchmark name is “PublisherFixture/ROS_BM_Publish_method” by var=size where subs_count=8 buffer=1000

#png(filename="plot.png", width = 1600, height = 900)
size <- c(1024, 4096, 16384, 65536, 262144, 1048576, 4194304, 16777216, 67108864)
real_time <- c(6057.0764683186035, 5419.77171932831, 9419.618730980223, 37114.691981497155, 243600.95310142808, 601452.4260553325, 1596832.6717077282, 25506102.50713297, 128046437.21431474)
cpu_time <- c(3008.9449492888198, 3309.6955330579476, 8141.305977483957, 31354.976325669682, 139800.24062381597, 403381.4325192258, 1182508.6655702316, 22445104.485725712, 94568736.32858397)
bytes_per_second <- c(1364425590.406985, 6129241916.539861, 13985284237.868042, 14200083765.948536, 8800792829.299368, 19398732091.098022, 21702803410.23856, 5320514158.94353, 4238887680.302912)
manual_bandwidth <- c(42677174734.15156, 26025516391.198513, 28941633241.141136, 12147668777.79102, 3328394580.4994574, 1060638106.6713841, 512917373.6292697, 147643137.72752073, 114433365.43745105)
manual_latency <- c(1986702.089213444, 6906430.322168343, 8342028.220107794, 24121523.844174843, 98086085.8001049, 134003672.71977839, 340102879.95178574, 1297891271.6, 4699079887.8)
df <- data.frame("factor"=size, "Время отправки (нс)"=real_time, "Время отправки CPU (нс)"=cpu_time, "Широта пропускания публикующего (б/с)"=bytes_per_second, "Широта пропускания принимающего (б/с)"=manual_bandwidth, "Задержка передачи (нс)"=manual_latency)
plot(factor(size, levels=size), real_time, type="o", col="black", lty=0, ylim=c(-83563979.3694256, 211613425.52868962), xlab="", ylab="")
points(factor(size, levels=size), real_time, col="black", pch="o")
lines(factor(size, levels=size), real_time, col="black", lty=1, lwd=2)
title(main="Зависимость задержки от фактора", xlab="Размер сообщения (б)", ylab="Задержка (нс)")
points(factor(size, levels=size), cpu_time, col="red", pch="X")
lines(factor(size, levels=size), cpu_time, col="red", lty=2, lwd=2)
legend("bottomright", legend=c("Время отправки (нс)", "Время отправки CPU (нс)"), col=c("black", "red"), lty=c(1, 2), pch=c("o", "X"), ncol=1)

plot(factor(size, levels=size), bytes_per_second, type="o", col="black", lty=0, ylim=c(-43155392199.13372, 85947000298.72272), xlab="", ylab="")
points(factor(size, levels=size), bytes_per_second, col="black", pch="o")
lines(factor(size, levels=size), bytes_per_second, col="black", lty=1, lwd=2)
title(main="Зависимость широты пропускания от фактора", xlab="Размер сообщения (б)", ylab="Широта пропускания (байт/сек)")
text( factor(size, levels=size), bytes_per_second, labels=bytes_per_second, cex= 0.7, pos=3)
points(factor(size, levels=size), manual_bandwidth, col="red", pch="X")
lines(factor(size, levels=size), manual_bandwidth, col="red", lty=2, lwd=2)
text( factor(size, levels=size), manual_bandwidth, labels=manual_bandwidth, cex= 0.7, pos=3)
legend("bottomright", legend=c("Широта пропускания публикующего (б/с)", "Широта пропускания принимающего (б/с)"), col=c("black", "red"), lty=c(1, 2), pch=c("o", "X"), ncol=1)

Benchmark name is “PublisherFixture/ROS_BM_Publish_method” by var=size where subs_count=8 buffer=10000

#png(filename="plot.png", width = 1600, height = 900)
size <- c(1024, 4096, 16384, 65536, 262144, 1048576, 4194304, 16777216, 67108864)
real_time <- c(5982.318517967719, 5512.324932717507, 9106.713305290123, 26744.575728683914, 76824.64563602976, 813896.3905363408, 1350034.4842400574, 25385952.37243373, 136672580.1200664)
cpu_time <- c(3003.2941593931237, 3321.7468407977713, 7877.725071927637, 13767.792037115656, 51768.185009942725, 496177.1286857225, 1125260.5958965074, 22495410.279310785, 95237181.67998594)
bytes_per_second <- c(1387171478.396817, 5992100707.579203, 14425173466.713476, 19674436567.124065, 29977588014.06074, 11799426264.071325, 25328765815.109386, 5306957246.9734745, 3988117682.2469215)
manual_bandwidth <- c(43473444560.08747, 38469930877.55172, 34264764504.390495, 2955778345.460847, 1411382350.8212028, 5200331369.972635, 609886016.6254795, 152538314.27993858, 93005388.66803208)
manual_latency <- c(2202890.4056161502, 6342390.803027696, 5255394.743360797, 82449028.50482565, 113611207.19254439, 147217498.16139644, 332545706.88531744, 1372224844.9, 4690898936.3)
df <- data.frame("factor"=size, "Время отправки (нс)"=real_time, "Время отправки CPU (нс)"=cpu_time, "Широта пропускания публикующего (б/с)"=bytes_per_second, "Широта пропускания принимающего (б/с)"=manual_bandwidth, "Задержка передачи (нс)"=manual_latency)
plot(factor(size, levels=size), real_time, type="o", col="black", lty=0, ylim=c(-93136849.20856184, 229812432.62278762), xlab="", ylab="")
points(factor(size, levels=size), real_time, col="black", pch="o")
lines(factor(size, levels=size), real_time, col="black", lty=1, lwd=2)
title(main="Зависимость задержки от фактора", xlab="Размер сообщения (б)", ylab="Задержка (нс)")
points(factor(size, levels=size), cpu_time, col="red", pch="X")
lines(factor(size, levels=size), cpu_time, col="red", lty=2, lwd=2)
legend("bottomright", legend=c("Время отправки (нс)", "Время отправки CPU (нс)"), col=c("black", "red"), lty=c(1, 2), pch=c("o", "X"), ncol=1)

plot(factor(size, levels=size), bytes_per_second, type="o", col="black", lty=0, ylim=c(-41218093297.651566, 84784543246.40707), xlab="", ylab="")
points(factor(size, levels=size), bytes_per_second, col="black", pch="o")
lines(factor(size, levels=size), bytes_per_second, col="black", lty=1, lwd=2)
title(main="Зависимость широты пропускания от фактора", xlab="Размер сообщения (б)", ylab="Широта пропускания (байт/сек)")
text( factor(size, levels=size), bytes_per_second, labels=bytes_per_second, cex= 0.7, pos=3)
points(factor(size, levels=size), manual_bandwidth, col="red", pch="X")
lines(factor(size, levels=size), manual_bandwidth, col="red", lty=2, lwd=2)
text( factor(size, levels=size), manual_bandwidth, labels=manual_bandwidth, cex= 0.7, pos=3)
legend("bottomright", legend=c("Широта пропускания публикующего (б/с)", "Широта пропускания принимающего (б/с)"), col=c("black", "red"), lty=c(1, 2), pch=c("o", "X"), ncol=1)

Benchmark name is “PublisherFixture/ROS_BM_Publish_method” by var=buffer where subs_count=1 size=1024

#png(filename="plot.png", width = 1600, height = 900)
buffer <- c(1, 10, 100, 1000, 10000)
real_time <- c(4580.186172553285, 4682.1144877890165, 4696.130734695629, 4647.609275461621, 4677.977688931564)
cpu_time <- c(3979.014066657179, 4022.6201363443483, 4043.0389562330433, 3996.525072522072, 4032.751272340824)
bytes_per_second <- c(223577799.00550812, 218715403.4698433, 218059518.18379253, 220334104.45400634, 218914227.22643536)
manual_bandwidth <- c(285570646.1227563, 266508563.34648475, 295981091.74113256, 233548707.55889267, 289649824.28957945)
manual_latency <- c(100541167.69730183, 89514370.37282008, 98827380.76116, 98645086.48662971, 99219020.04579222)
df <- data.frame("factor"=buffer, "Время отправки (нс)"=real_time, "Время отправки CPU (нс)"=cpu_time, "Широта пропускания публикующего (б/с)"=bytes_per_second, "Широта пропускания принимающего (б/с)"=manual_bandwidth, "Задержка передачи (нс)"=manual_latency)
plot(factor(buffer, levels=buffer), real_time, type="o", col="black", lty=0, ylim=c(3559.511291895469, 5115.633509457338), xlab="", ylab="")
points(factor(buffer, levels=buffer), real_time, col="black", pch="o")
lines(factor(buffer, levels=buffer), real_time, col="black", lty=1, lwd=2)
title(main="Зависимость задержки от фактора", xlab="Размер буфера", ylab="Задержка (нс)")
points(factor(buffer, levels=buffer), cpu_time, col="red", pch="X")
lines(factor(buffer, levels=buffer), cpu_time, col="red", lty=2, lwd=2)
legend("bottomright", legend=c("Время отправки (нс)", "Время отправки CPU (нс)"), col=c("black", "red"), lty=c(1, 2), pch=c("o", "X"), ncol=1)

plot(factor(buffer, levels=buffer), bytes_per_second, type="o", col="black", lty=0, ylim=c(136570150.77981973, 377470459.14510536), xlab="", ylab="")
points(factor(buffer, levels=buffer), bytes_per_second, col="black", pch="o")
lines(factor(buffer, levels=buffer), bytes_per_second, col="black", lty=1, lwd=2)
title(main="Зависимость широты пропускания от фактора", xlab="Размер буфера", ylab="Широта пропускания (байт/сек)")
text( factor(buffer, levels=buffer), bytes_per_second, labels=bytes_per_second, cex= 0.7, pos=3)
points(factor(buffer, levels=buffer), manual_bandwidth, col="red", pch="X")
lines(factor(buffer, levels=buffer), manual_bandwidth, col="red", lty=2, lwd=2)
text( factor(buffer, levels=buffer), manual_bandwidth, labels=manual_bandwidth, cex= 0.7, pos=3)
legend("bottomright", legend=c("Широта пропускания публикующего (б/с)", "Широта пропускания принимающего (б/с)"), col=c("black", "red"), lty=c(1, 2), pch=c("o", "X"), ncol=1)

Benchmark name is “PublisherFixture/ROS_BM_Publish_method” by var=buffer where subs_count=1 size=4096

#png(filename="plot.png", width = 1600, height = 900)
buffer <- c(1, 10, 100, 1000, 10000)
real_time <- c(5141.29448106764, 5086.4825499693825, 4996.712260876187, 4914.350042001504, 4930.20967126802)
cpu_time <- c(4555.869325588748, 4520.956539210994, 4484.187911371033, 4390.631452501739, 4406.624640378626)
bytes_per_second <- c(796736934.3596822, 805315086.1682184, 819773825.8472631, 833495450.3921818, 830833871.4981556)
manual_bandwidth <- c(562460814.8161839, 541051935.4185402, 519480747.8371477, 517619176.04281694, 532817554.3644816)
manual_latency <- c(73825278.00071314, 77874221.18243358, 78586582.6695374, 79166648.66358423, 78445081.83738217)
df <- data.frame("factor"=buffer, "Время отправки (нс)"=real_time, "Время отправки CPU (нс)"=cpu_time, "Широта пропускания публикующего (б/с)"=bytes_per_second, "Широта пропускания принимающего (б/с)"=manual_bandwidth, "Задержка передачи (нс)"=manual_latency)
plot(factor(buffer, levels=buffer), real_time, type="o", col="black", lty=0, ylim=c(3953.7800568594175, 5578.145876709961), xlab="", ylab="")
points(factor(buffer, levels=buffer), real_time, col="black", pch="o")
lines(factor(buffer, levels=buffer), real_time, col="black", lty=1, lwd=2)
title(main="Зависимость задержки от фактора", xlab="Размер буфера", ylab="Задержка (нс)")
points(factor(buffer, levels=buffer), cpu_time, col="red", pch="X")
lines(factor(buffer, levels=buffer), cpu_time, col="red", lty=2, lwd=2)
legend("bottomright", legend=c("Время отправки (нс)", "Время отправки CPU (нс)"), col=c("black", "red"), lty=c(1, 2), pch=c("o", "X"), ncol=1)

plot(factor(buffer, levels=buffer), bytes_per_second, type="o", col="black", lty=0, ylim=c(308379063.7970506, 1042735562.6379482), xlab="", ylab="")
points(factor(buffer, levels=buffer), bytes_per_second, col="black", pch="o")
lines(factor(buffer, levels=buffer), bytes_per_second, col="black", lty=1, lwd=2)
title(main="Зависимость широты пропускания от фактора", xlab="Размер буфера", ylab="Широта пропускания (байт/сек)")
text( factor(buffer, levels=buffer), bytes_per_second, labels=bytes_per_second, cex= 0.7, pos=3)
points(factor(buffer, levels=buffer), manual_bandwidth, col="red", pch="X")
lines(factor(buffer, levels=buffer), manual_bandwidth, col="red", lty=2, lwd=2)
text( factor(buffer, levels=buffer), manual_bandwidth, labels=manual_bandwidth, cex= 0.7, pos=3)
legend("bottomright", legend=c("Широта пропускания публикующего (б/с)", "Широта пропускания принимающего (б/с)"), col=c("black", "red"), lty=c(1, 2), pch=c("o", "X"), ncol=1)

Benchmark name is “PublisherFixture/ROS_BM_Publish_method” by var=buffer where subs_count=1 size=16384

#png(filename="plot.png", width = 1600, height = 900)
buffer <- c(1, 10, 100, 1000, 10000)
real_time <- c(11413.245646123949, 10797.271739557818, 9838.876178620927, 10817.46587170375, 10032.899855836778)
cpu_time <- c(10687.832977406468, 10110.794076117785, 9185.984708335725, 10111.225631437, 9360.39266823885)
bytes_per_second <- c(1444943827.793212, 1522427786.9583912, 1672845539.8542438, 1552375281.0753336, 1634542267.3890026)
manual_bandwidth <- c(4854025925.934568, 4244976091.8839583, 5039883825.957062, 3521025198.331669, 8555976419.073015)
manual_latency <- c(3676285.601414365, 10023994.052193463, 6987833.432573368, 12683969.933360163, 4338464.470109924)
df <- data.frame("factor"=buffer, "Время отправки (нс)"=real_time, "Время отправки CPU (нс)"=cpu_time, "Широта пропускания публикующего (б/с)"=bytes_per_second, "Широта пропускания принимающего (б/с)"=manual_bandwidth, "Задержка передачи (нс)"=manual_latency)
plot(factor(buffer, levels=buffer), real_time, type="o", col="black", lty=0, ylim=c(5578.1565791488865, 15021.073775310788), xlab="", ylab="")
points(factor(buffer, levels=buffer), real_time, col="black", pch="o")
lines(factor(buffer, levels=buffer), real_time, col="black", lty=1, lwd=2)
title(main="Зависимость задержки от фактора", xlab="Размер буфера", ylab="Задержка (нс)")
points(factor(buffer, levels=buffer), cpu_time, col="red", pch="X")
lines(factor(buffer, levels=buffer), cpu_time, col="red", lty=2, lwd=2)
legend("bottomright", legend=c("Время отправки (нс)", "Время отправки CPU (нс)"), col=c("black", "red"), lty=c(1, 2), pch=c("o", "X"), ncol=1)

plot(factor(buffer, levels=buffer), bytes_per_second, type="o", col="black", lty=0, ylim=c(-5935913103.245405, 15936833350.111633), xlab="", ylab="")
points(factor(buffer, levels=buffer), bytes_per_second, col="black", pch="o")
lines(factor(buffer, levels=buffer), bytes_per_second, col="black", lty=1, lwd=2)
title(main="Зависимость широты пропускания от фактора", xlab="Размер буфера", ylab="Широта пропускания (байт/сек)")
text( factor(buffer, levels=buffer), bytes_per_second, labels=bytes_per_second, cex= 0.7, pos=3)
points(factor(buffer, levels=buffer), manual_bandwidth, col="red", pch="X")
lines(factor(buffer, levels=buffer), manual_bandwidth, col="red", lty=2, lwd=2)
text( factor(buffer, levels=buffer), manual_bandwidth, labels=manual_bandwidth, cex= 0.7, pos=3)
legend("bottomright", legend=c("Широта пропускания публикующего (б/с)", "Широта пропускания принимающего (б/с)"), col=c("black", "red"), lty=c(1, 2), pch=c("o", "X"), ncol=1)

Benchmark name is “PublisherFixture/ROS_BM_Publish_method” by var=buffer where subs_count=1 size=65536

#png(filename="plot.png", width = 1600, height = 900)
buffer <- c(1, 10, 100, 1000, 10000)
real_time <- c(35241.86476183732, 32294.890055415395, 27581.031056461135, 32410.539184549638, 30851.068553369067)
cpu_time <- c(33241.20863759325, 30496.115490451182, 25898.2559040687, 30571.879910891334, 29106.578206122278)
bytes_per_second <- c(1904870091.11708, 2159542493.6796823, 2410643142.9612517, 2039646241.2514234, 2187382139.450816)
manual_bandwidth <- c(1594122789.7331998, 809782798.6633061, 939146864.5975126, 1267576171.691979, 1099325007.183746)
manual_latency <- c(39326305.28582083, 51469032.88383031, 60921372.31911387, 45286113.04486585, 46460204.54936122)
df <- data.frame("factor"=buffer, "Время отправки (нс)"=real_time, "Время отправки CPU (нс)"=cpu_time, "Широта пропускания публикующего (б/с)"=bytes_per_second, "Широта пропускания принимающего (б/с)"=manual_bandwidth, "Задержка передачи (нс)"=manual_latency)
plot(factor(buffer, levels=buffer), real_time, type="o", col="black", lty=0, ylim=c(8097.614932231876, 53042.505733674145), xlab="", ylab="")
points(factor(buffer, levels=buffer), real_time, col="black", pch="o")
lines(factor(buffer, levels=buffer), real_time, col="black", lty=1, lwd=2)
title(main="Зависимость задержки от фактора", xlab="Размер буфера", ylab="Задержка (нс)")
points(factor(buffer, levels=buffer), cpu_time, col="red", pch="X")
lines(factor(buffer, levels=buffer), cpu_time, col="red", lty=2, lwd=2)
legend("bottomright", legend=c("Время отправки (нс)", "Время отправки CPU (нс)"), col=c("black", "red"), lty=c(1, 2), pch=c("o", "X"), ncol=1)

plot(factor(buffer, levels=buffer), bytes_per_second, type="o", col="black", lty=0, ylim=c(-1555273621.6244311, 4775699563.248989), xlab="", ylab="")
points(factor(buffer, levels=buffer), bytes_per_second, col="black", pch="o")
lines(factor(buffer, levels=buffer), bytes_per_second, col="black", lty=1, lwd=2)
title(main="Зависимость широты пропускания от фактора", xlab="Размер буфера", ylab="Широта пропускания (байт/сек)")
text( factor(buffer, levels=buffer), bytes_per_second, labels=bytes_per_second, cex= 0.7, pos=3)
points(factor(buffer, levels=buffer), manual_bandwidth, col="red", pch="X")
lines(factor(buffer, levels=buffer), manual_bandwidth, col="red", lty=2, lwd=2)
text( factor(buffer, levels=buffer), manual_bandwidth, labels=manual_bandwidth, cex= 0.7, pos=3)
legend("bottomright", legend=c("Широта пропускания публикующего (б/с)", "Широта пропускания принимающего (б/с)"), col=c("black", "red"), lty=c(1, 2), pch=c("o", "X"), ncol=1)

Benchmark name is “PublisherFixture/ROS_BM_Publish_method” by var=buffer where subs_count=1 size=262144

#png(filename="plot.png", width = 1600, height = 900)
buffer <- c(1, 10, 100, 1000, 10000)
real_time <- c(114268.43880865749, 93697.43355981298, 115074.4071538304, 83764.88011132626, 100852.87849219091)
cpu_time <- c(108479.34467634936, 89347.84447660146, 109212.65418650089, 80272.52386504423, 96188.6194666941)
bytes_per_second <- c(2323881701.4534497, 2926476322.412967, 2285440169.120406, 3139900191.558425, 2675212009.490981)
manual_bandwidth <- c(561893310.21282, 489084389.21603614, 660527389.5495522, 692023701.5569701, 629218457.0725011)
manual_latency <- c(76813681.20076752, 77811452.96430251, 68887668.59135279, 78444876.04642949, 77162712.9916431)
df <- data.frame("factor"=buffer, "Время отправки (нс)"=real_time, "Время отправки CPU (нс)"=cpu_time, "Широта пропускания публикующего (б/с)"=bytes_per_second, "Широта пропускания принимающего (б/с)"=manual_bandwidth, "Задержка передачи (нс)"=manual_latency)
plot(factor(buffer, levels=buffer), real_time, type="o", col="black", lty=0, ylim=c(34058.89482753265, 161288.036191342), xlab="", ylab="")
points(factor(buffer, levels=buffer), real_time, col="black", pch="o")
lines(factor(buffer, levels=buffer), real_time, col="black", lty=1, lwd=2)
title(main="Зависимость задержки от фактора", xlab="Размер буфера", ylab="Задержка (нс)")
points(factor(buffer, levels=buffer), cpu_time, col="red", pch="X")
lines(factor(buffer, levels=buffer), cpu_time, col="red", lty=2, lwd=2)
legend("bottomright", legend=c("Время отправки (нс)", "Время отправки CPU (нс)"), col=c("black", "red"), lty=c(1, 2), pch=c("o", "X"), ncol=1)

plot(factor(buffer, levels=buffer), bytes_per_second, type="o", col="black", lty=0, ylim=c(-1836846413.778948, 5465830994.55341), xlab="", ylab="")
points(factor(buffer, levels=buffer), bytes_per_second, col="black", pch="o")
lines(factor(buffer, levels=buffer), bytes_per_second, col="black", lty=1, lwd=2)
title(main="Зависимость широты пропускания от фактора", xlab="Размер буфера", ylab="Широта пропускания (байт/сек)")
text( factor(buffer, levels=buffer), bytes_per_second, labels=bytes_per_second, cex= 0.7, pos=3)
points(factor(buffer, levels=buffer), manual_bandwidth, col="red", pch="X")
lines(factor(buffer, levels=buffer), manual_bandwidth, col="red", lty=2, lwd=2)
text( factor(buffer, levels=buffer), manual_bandwidth, labels=manual_bandwidth, cex= 0.7, pos=3)
legend("bottomright", legend=c("Широта пропускания публикующего (б/с)", "Широта пропускания принимающего (б/с)"), col=c("black", "red"), lty=c(1, 2), pch=c("o", "X"), ncol=1)

Benchmark name is “PublisherFixture/ROS_BM_Publish_method” by var=buffer where subs_count=1 size=1048576

#png(filename="plot.png", width = 1600, height = 900)
buffer <- c(1, 10, 100, 1000, 10000)
real_time <- c(1045110.7708889504, 1043938.4474867955, 1051105.2499288847, 1044106.2189312959, 1052824.5458658107)
cpu_time <- c(1006048.5644091123, 1009134.8073967369, 1004895.4915821294, 996014.952023052, 1002082.1166906192)
bytes_per_second <- c(1003449314.9936724, 1004721114.4900757, 997716470.024121, 1004412110.5288732, 996056474.4295423)
manual_bandwidth <- c(105805925.1746181, 71085398.25787535, 90615069.17813474, 175012270.98146084, 142791755.3746472)
manual_latency <- c(137343184.1157684, 152659687.22916666, 125700754.313254, 101784359.23296383, 102741443.81669703)
df <- data.frame("factor"=buffer, "Время отправки (нс)"=real_time, "Время отправки CPU (нс)"=cpu_time, "Широта пропускания публикующего (б/с)"=bytes_per_second, "Широта пропускания принимающего (б/с)"=manual_bandwidth, "Задержка передачи (нс)"=manual_latency)
plot(factor(buffer, levels=buffer), real_time, type="o", col="black", lty=0, ylim=c(941430.0144348763, 1107409.4834539865), xlab="", ylab="")
points(factor(buffer, levels=buffer), real_time, col="black", pch="o")
lines(factor(buffer, levels=buffer), real_time, col="black", lty=1, lwd=2)
title(main="Зависимость задержки от фактора", xlab="Размер буфера", ylab="Задержка (нс)")
points(factor(buffer, levels=buffer), cpu_time, col="red", pch="X")
lines(factor(buffer, levels=buffer), cpu_time, col="red", lty=2, lwd=2)
legend("bottomright", legend=c("Время отправки (нс)", "Время отправки CPU (нс)"), col=c("black", "red"), lty=c(1, 2), pch=c("o", "X"), ncol=1)

plot(factor(buffer, levels=buffer), bytes_per_second, type="o", col="black", lty=0, ylim=c(-551054009.0923331, 1626860521.840284), xlab="", ylab="")
points(factor(buffer, levels=buffer), bytes_per_second, col="black", pch="o")
lines(factor(buffer, levels=buffer), bytes_per_second, col="black", lty=1, lwd=2)
title(main="Зависимость широты пропускания от фактора", xlab="Размер буфера", ylab="Широта пропускания (байт/сек)")
text( factor(buffer, levels=buffer), bytes_per_second, labels=bytes_per_second, cex= 0.7, pos=3)
points(factor(buffer, levels=buffer), manual_bandwidth, col="red", pch="X")
lines(factor(buffer, levels=buffer), manual_bandwidth, col="red", lty=2, lwd=2)
text( factor(buffer, levels=buffer), manual_bandwidth, labels=manual_bandwidth, cex= 0.7, pos=3)
legend("bottomright", legend=c("Широта пропускания публикующего (б/с)", "Широта пропускания принимающего (б/с)"), col=c("black", "red"), lty=c(1, 2), pch=c("o", "X"), ncol=1)

Benchmark name is “PublisherFixture/ROS_BM_Publish_method” by var=buffer where subs_count=1 size=4194304

#png(filename="plot.png", width = 1600, height = 900)
buffer <- c(1, 10, 100, 1000, 10000)
real_time <- c(3753850.3210739205, 2538826.699143001, 2434603.9247404262, 3573191.76375081, 2344889.4259120347)
cpu_time <- c(3713596.038016802, 2497592.8508471227, 2402506.9499997115, 3540859.590603914, 2321858.0445348253)
bytes_per_second <- c(1217603642.0833662, 2222609749.2521906, 1876029897.5067196, 1226689567.3281274, 2134439129.120278)
manual_bandwidth <- c(16458417.004081905, 38100873.85264189, 49531512.28005635, 28570435.29598547, 43746289.07796217)
manual_latency <- c(590373219.65, 407792625.5516667, 382650046.6, 376512161.325, 349799361.53166664)
df <- data.frame("factor"=buffer, "Время отправки (нс)"=real_time, "Время отправки CPU (нс)"=cpu_time, "Широта пропускания публикующего (б/с)"=bytes_per_second, "Широта пропускания принимающего (б/с)"=manual_bandwidth, "Задержка передачи (нс)"=manual_latency)
plot(factor(buffer, levels=buffer), real_time, type="o", col="black", lty=0, ylim=c(-369052.44975544256, 6444760.8153641885), xlab="", ylab="")
points(factor(buffer, levels=buffer), real_time, col="black", pch="o")
lines(factor(buffer, levels=buffer), real_time, col="black", lty=1, lwd=2)
title(main="Зависимость задержки от фактора", xlab="Размер буфера", ylab="Задержка (нс)")
points(factor(buffer, levels=buffer), cpu_time, col="red", pch="X")
lines(factor(buffer, levels=buffer), cpu_time, col="red", lty=2, lwd=2)
legend("bottomright", legend=c("Время отправки (нс)", "Время отправки CPU (нс)"), col=c("black", "red"), lty=c(1, 2), pch=c("o", "X"), ncol=1)

plot(factor(buffer, levels=buffer), bytes_per_second, type="o", col="black", lty=0, ylim=c(-2953015712.471532, 5192083878.727804), xlab="", ylab="")
points(factor(buffer, levels=buffer), bytes_per_second, col="black", pch="o")
lines(factor(buffer, levels=buffer), bytes_per_second, col="black", lty=1, lwd=2)
title(main="Зависимость широты пропускания от фактора", xlab="Размер буфера", ylab="Широта пропускания (байт/сек)")
text( factor(buffer, levels=buffer), bytes_per_second, labels=bytes_per_second, cex= 0.7, pos=3)
points(factor(buffer, levels=buffer), manual_bandwidth, col="red", pch="X")
lines(factor(buffer, levels=buffer), manual_bandwidth, col="red", lty=2, lwd=2)
text( factor(buffer, levels=buffer), manual_bandwidth, labels=manual_bandwidth, cex= 0.7, pos=3)
legend("bottomright", legend=c("Широта пропускания публикующего (б/с)", "Широта пропускания принимающего (б/с)"), col=c("black", "red"), lty=c(1, 2), pch=c("o", "X"), ncol=1)

Benchmark name is “PublisherFixture/ROS_BM_Publish_method” by var=buffer where subs_count=1 size=16777216

#png(filename="plot.png", width = 1600, height = 900)
buffer <- c(1, 10, 100, 1000, 10000)
real_time <- c(21395027.363643862, 21004428.776471764, 20703334.917135566, 20928469.642888427, 21080164.358799644)
cpu_time <- c(20282776.990910977, 20058544.814708058, 20001775.965714283, 20107569.845712792, 20199333.585295126)
bytes_per_second <- c(784414946.7656333, 798853509.4188143, 810590878.1915822, 802032047.0617198, 795992774.0525539)
manual_bandwidth <- c(25394987.034445845, 17397175.311926328, 13619220.63213782, 19075255.851903733, 26685113.049180597)
manual_latency <- c(1127483215.9, 1317382247.15, 1411569675.05, 1282624062.85, 1113078642.0)
df <- data.frame("factor"=buffer, "Время отправки (нс)"=real_time, "Время отправки CPU (нс)"=cpu_time, "Широта пропускания публикующего (б/с)"=bytes_per_second, "Широта пропускания принимающего (б/с)"=manual_bandwidth, "Задержка передачи (нс)"=manual_latency)
plot(factor(buffer, levels=buffer), real_time, type="o", col="black", lty=0, ylim=c(18621870.2878896, 22774933.041468546), xlab="", ylab="")
points(factor(buffer, levels=buffer), real_time, col="black", pch="o")
lines(factor(buffer, levels=buffer), real_time, col="black", lty=1, lwd=2)
title(main="Зависимость задержки от фактора", xlab="Размер буфера", ylab="Задержка (нс)")
points(factor(buffer, levels=buffer), cpu_time, col="red", pch="X")
lines(factor(buffer, levels=buffer), cpu_time, col="red", lty=2, lwd=2)
legend("bottomright", legend=c("Время отправки (нс)", "Время отправки CPU (нс)"), col=c("black", "red"), lty=c(1, 2), pch=c("o", "X"), ncol=1)

plot(factor(buffer, levels=buffer), bytes_per_second, type="o", col="black", lty=0, ylim=c(-411790909.80443203, 1236001008.6281521), xlab="", ylab="")
points(factor(buffer, levels=buffer), bytes_per_second, col="black", pch="o")
lines(factor(buffer, levels=buffer), bytes_per_second, col="black", lty=1, lwd=2)
title(main="Зависимость широты пропускания от фактора", xlab="Размер буфера", ylab="Широта пропускания (байт/сек)")
text( factor(buffer, levels=buffer), bytes_per_second, labels=bytes_per_second, cex= 0.7, pos=3)
points(factor(buffer, levels=buffer), manual_bandwidth, col="red", pch="X")
lines(factor(buffer, levels=buffer), manual_bandwidth, col="red", lty=2, lwd=2)
text( factor(buffer, levels=buffer), manual_bandwidth, labels=manual_bandwidth, cex= 0.7, pos=3)
legend("bottomright", legend=c("Широта пропускания публикующего (б/с)", "Широта пропускания принимающего (б/с)"), col=c("black", "red"), lty=c(1, 2), pch=c("o", "X"), ncol=1)

Benchmark name is “PublisherFixture/ROS_BM_Publish_method” by var=buffer where subs_count=1 size=67108864

#png(filename="plot.png", width = 1600, height = 900)
buffer <- c(1, 10, 100, 1000, 10000)
real_time <- c(86678925.24996433, 86175066.38751139, 85672930.42501661, 84531585.93753187, 84508287.60006744)
cpu_time <- c(85284846.61250034, 84428311.06249854, 83528424.77499607, 83198716.40000471, 83497380.48749842)
bytes_per_second <- c(774956270.4606626, 779016401.2050602, 783521912.9193466, 794131967.7890902, 794310429.5221562)
manual_bandwidth <- c(19110785.712584555, 17568500.79245288, 17636101.26386756, 17661296.76422714, 13972486.088328427)
manual_latency <- c(3856921917.3, 3821787509.6, 3807758396.2, 3802408177.5, 3073897082.7)
df <- data.frame("factor"=buffer, "Время отправки (нс)"=real_time, "Время отправки CPU (нс)"=cpu_time, "Широта пропускания публикующего (б/с)"=bytes_per_second, "Широта пропускания принимающего (б/с)"=manual_bandwidth, "Задержка передачи (нс)"=manual_latency)
plot(factor(buffer, levels=buffer), real_time, type="o", col="black", lty=0, ylim=c(77394683.23288816, 92482958.41708088), xlab="", ylab="")
points(factor(buffer, levels=buffer), real_time, col="black", pch="o")
lines(factor(buffer, levels=buffer), real_time, col="black", lty=1, lwd=2)
title(main="Зависимость задержки от фактора", xlab="Размер буфера", ylab="Задержка (нс)")
points(factor(buffer, levels=buffer), cpu_time, col="red", pch="X")
lines(factor(buffer, levels=buffer), cpu_time, col="red", lty=2, lwd=2)
legend("bottomright", legend=c("Время отправки (нс)", "Время отправки CPU (нс)"), col=c("black", "red"), lty=c(1, 2), pch=c("o", "X"), ncol=1)

plot(factor(buffer, levels=buffer), bytes_per_second, type="o", col="black", lty=0, ylim=c(-411752107.04511356, 1220035022.6555982), xlab="", ylab="")
points(factor(buffer, levels=buffer), bytes_per_second, col="black", pch="o")
lines(factor(buffer, levels=buffer), bytes_per_second, col="black", lty=1, lwd=2)
title(main="Зависимость широты пропускания от фактора", xlab="Размер буфера", ylab="Широта пропускания (байт/сек)")
text( factor(buffer, levels=buffer), bytes_per_second, labels=bytes_per_second, cex= 0.7, pos=3)
points(factor(buffer, levels=buffer), manual_bandwidth, col="red", pch="X")
lines(factor(buffer, levels=buffer), manual_bandwidth, col="red", lty=2, lwd=2)
text( factor(buffer, levels=buffer), manual_bandwidth, labels=manual_bandwidth, cex= 0.7, pos=3)
legend("bottomright", legend=c("Широта пропускания публикующего (б/с)", "Широта пропускания принимающего (б/с)"), col=c("black", "red"), lty=c(1, 2), pch=c("o", "X"), ncol=1)

Benchmark name is “PublisherFixture/ROS_BM_Publish_method” by var=buffer where subs_count=2 size=1024

#png(filename="plot.png", width = 1600, height = 900)
buffer <- c(1, 10, 100, 1000, 10000)
real_time <- c(5157.011854205701, 4786.512908634228, 4788.4441863204265, 4785.349781783731, 4820.713313170985)
cpu_time <- c(4074.007642896597, 3977.817551199181, 3942.1589292166345, 3949.1776102545314, 3975.039859758196)
bytes_per_second <- c(397220849.88300574, 427877594.2851998, 427712338.78835094, 427979202.6862031, 425490283.8058814)
manual_bandwidth <- c(488726486.6053093, 13510473485.041466, 11753311273.55764, 11971461234.445177, 7387770172.393695)
manual_latency <- c(82142198.40676616, 3681929.9947898104, 5016327.149989426, 4393799.865931442, 13871864.109881664)
df <- data.frame("factor"=buffer, "Время отправки (нс)"=real_time, "Время отправки CPU (нс)"=cpu_time, "Широта пропускания публикующего (б/с)"=bytes_per_second, "Широта пропускания принимающего (б/с)"=manual_bandwidth, "Задержка передачи (нс)"=manual_latency)
plot(factor(buffer, levels=buffer), real_time, type="o", col="black", lty=0, ylim=c(3034.182299284413, 6064.988484137923), xlab="", ylab="")
points(factor(buffer, levels=buffer), real_time, col="black", pch="o")
lines(factor(buffer, levels=buffer), real_time, col="black", lty=1, lwd=2)
title(main="Зависимость задержки от фактора", xlab="Размер буфера", ylab="Задержка (нс)")
points(factor(buffer, levels=buffer), cpu_time, col="red", pch="X")
lines(factor(buffer, levels=buffer), cpu_time, col="red", lty=2, lwd=2)
legend("bottomright", legend=c("Время отправки (нс)", "Время отправки CPU (нс)"), col=c("black", "red"), lty=c(1, 2), pch=c("o", "X"), ncol=1)

plot(factor(buffer, levels=buffer), bytes_per_second, type="o", col="black", lty=0, ylim=c(-11460548742.453701, 25368243077.378174), xlab="", ylab="")
points(factor(buffer, levels=buffer), bytes_per_second, col="black", pch="o")
lines(factor(buffer, levels=buffer), bytes_per_second, col="black", lty=1, lwd=2)
title(main="Зависимость широты пропускания от фактора", xlab="Размер буфера", ylab="Широта пропускания (байт/сек)")
text( factor(buffer, levels=buffer), bytes_per_second, labels=bytes_per_second, cex= 0.7, pos=3)
points(factor(buffer, levels=buffer), manual_bandwidth, col="red", pch="X")
lines(factor(buffer, levels=buffer), manual_bandwidth, col="red", lty=2, lwd=2)
text( factor(buffer, levels=buffer), manual_bandwidth, labels=manual_bandwidth, cex= 0.7, pos=3)
legend("bottomright", legend=c("Широта пропускания публикующего (б/с)", "Широта пропускания принимающего (б/с)"), col=c("black", "red"), lty=c(1, 2), pch=c("o", "X"), ncol=1)

Benchmark name is “PublisherFixture/ROS_BM_Publish_method” by var=buffer where subs_count=2 size=4096

#png(filename="plot.png", width = 1600, height = 900)
buffer <- c(1, 10, 100, 1000, 10000)
real_time <- c(5066.614075190955, 5010.18803186704, 4992.848741784826, 5008.709241208635, 4968.031603459658)
cpu_time <- c(4390.646898982709, 4358.697393979326, 4342.987223008087, 4355.563179992146, 4330.63404212249)
bytes_per_second <- c(1617027284.1902287, 1635137728.5418162, 1640815507.0075707, 1635620657.844274, 1649071796.7249732)
manual_bandwidth <- c(868839785.6372092, 1189163222.6229599, 1051863292.1080315, 769163817.824446, 1089872499.312002)
manual_latency <- c(69236999.46569867, 69397024.38562232, 77179944.7658565, 77771458.24521479, 76338393.0376416)
df <- data.frame("factor"=buffer, "Время отправки (нс)"=real_time, "Время отправки CPU (нс)"=cpu_time, "Широта пропускания публикующего (б/с)"=bytes_per_second, "Широта пропускания принимающего (б/с)"=manual_bandwidth, "Задержка передачи (нс)"=manual_latency)
plot(factor(buffer, levels=buffer), real_time, type="o", col="black", lty=0, ylim=c(3884.544162699463, 5512.703954613983), xlab="", ylab="")
points(factor(buffer, levels=buffer), real_time, col="black", pch="o")
lines(factor(buffer, levels=buffer), real_time, col="black", lty=1, lwd=2)
title(main="Зависимость задержки от фактора", xlab="Размер буфера", ylab="Задержка (нс)")
points(factor(buffer, levels=buffer), cpu_time, col="red", pch="X")
lines(factor(buffer, levels=buffer), cpu_time, col="red", lty=2, lwd=2)
legend("bottomright", legend=c("Время отправки (нс)", "Время отправки CPU (нс)"), col=c("black", "red"), lty=c(1, 2), pch=c("o", "X"), ncol=1)

plot(factor(buffer, levels=buffer), bytes_per_second, type="o", col="black", lty=0, ylim=c(272941997.68285334, 2145293616.8665657), xlab="", ylab="")
points(factor(buffer, levels=buffer), bytes_per_second, col="black", pch="o")
lines(factor(buffer, levels=buffer), bytes_per_second, col="black", lty=1, lwd=2)
title(main="Зависимость широты пропускания от фактора", xlab="Размер буфера", ylab="Широта пропускания (байт/сек)")
text( factor(buffer, levels=buffer), bytes_per_second, labels=bytes_per_second, cex= 0.7, pos=3)
points(factor(buffer, levels=buffer), manual_bandwidth, col="red", pch="X")
lines(factor(buffer, levels=buffer), manual_bandwidth, col="red", lty=2, lwd=2)
text( factor(buffer, levels=buffer), manual_bandwidth, labels=manual_bandwidth, cex= 0.7, pos=3)
legend("bottomright", legend=c("Широта пропускания публикующего (б/с)", "Широта пропускания принимающего (б/с)"), col=c("black", "red"), lty=c(1, 2), pch=c("o", "X"), ncol=1)

Benchmark name is “PublisherFixture/ROS_BM_Publish_method” by var=buffer where subs_count=2 size=16384

#png(filename="plot.png", width = 1600, height = 900)
buffer <- c(1, 10, 100, 1000, 10000)
real_time <- c(7521.461427117245, 9648.827123774035, 9307.297751659746, 8786.187739685674, 8932.244906434218)
cpu_time <- c(6941.257041351013, 8940.691778472941, 8598.71304644371, 8123.481326494989, 8256.99268562074)
bytes_per_second <- c(4405431196.978784, 3426325958.521861, 3569727017.760775, 3791193511.2788916, 3687889300.5797815)
manual_bandwidth <- c(6882682990.76209, 8547580529.917875, 7020589668.383814, 6562330665.497423, 8256254659.259003)
manual_latency <- c(35454693.13271073, 6082395.292379005, 13708409.237381566, 8357396.402100799, 10419793.151907107)
df <- data.frame("factor"=buffer, "Время отправки (нс)"=real_time, "Время отправки CPU (нс)"=cpu_time, "Широта пропускания публикующего (б/с)"=bytes_per_second, "Широта пропускания принимающего (б/с)"=manual_bandwidth, "Задержка передачи (нс)"=manual_latency)
plot(factor(buffer, levels=buffer), real_time, type="o", col="black", lty=0, ylim=c(3936.3475321073147, 12653.736633017734), xlab="", ylab="")
points(factor(buffer, levels=buffer), real_time, col="black", pch="o")
lines(factor(buffer, levels=buffer), real_time, col="black", lty=1, lwd=2)
title(main="Зависимость задержки от фактора", xlab="Размер буфера", ylab="Задержка (нс)")
points(factor(buffer, levels=buffer), cpu_time, col="red", pch="X")
lines(factor(buffer, levels=buffer), cpu_time, col="red", lty=2, lwd=2)
legend("bottomright", legend=c("Время отправки (нс)", "Время отправки CPU (нс)"), col=c("black", "red"), lty=c(1, 2), pch=c("o", "X"), ncol=1)

plot(factor(buffer, levels=buffer), bytes_per_second, type="o", col="black", lty=0, ylim=c(-8902577074.608803, 20876483563.04854), xlab="", ylab="")
points(factor(buffer, levels=buffer), bytes_per_second, col="black", pch="o")
lines(factor(buffer, levels=buffer), bytes_per_second, col="black", lty=1, lwd=2)
title(main="Зависимость широты пропускания от фактора", xlab="Размер буфера", ylab="Широта пропускания (байт/сек)")
text( factor(buffer, levels=buffer), bytes_per_second, labels=bytes_per_second, cex= 0.7, pos=3)
points(factor(buffer, levels=buffer), manual_bandwidth, col="red", pch="X")
lines(factor(buffer, levels=buffer), manual_bandwidth, col="red", lty=2, lwd=2)
text( factor(buffer, levels=buffer), manual_bandwidth, labels=manual_bandwidth, cex= 0.7, pos=3)
legend("bottomright", legend=c("Широта пропускания публикующего (б/с)", "Широта пропускания принимающего (б/с)"), col=c("black", "red"), lty=c(1, 2), pch=c("o", "X"), ncol=1)

Benchmark name is “PublisherFixture/ROS_BM_Publish_method” by var=buffer where subs_count=2 size=65536

#png(filename="plot.png", width = 1600, height = 900)
buffer <- c(1, 10, 100, 1000, 10000)
real_time <- c(34846.32125337281, 17500.153627816115, 28008.43602805565, 42374.0165652213, 28791.789275937354)
cpu_time <- c(32616.890693069163, 16762.5256312205, 26223.890796388507, 39491.78780987342, 27099.29849543299)
bytes_per_second <- c(3823183776.5883217, 7706105140.572764, 5101436170.133032, 3146917715.8547606, 4673009781.780072)
manual_bandwidth <- c(4092402725.4754357, 1003249693.6337998, 7171677046.238512, 6653376706.351194, 4783599694.026499)
manual_latency <- c(22585023.41780781, 64216843.20106669, 35890701.40487538, 9491419.226514764, 33457553.783326417)
df <- data.frame("factor"=buffer, "Время отправки (нс)"=real_time, "Время отправки CPU (нс)"=cpu_time, "Широта пропускания публикующего (б/с)"=bytes_per_second, "Широта пропускания принимающего (б/с)"=manual_bandwidth, "Задержка передачи (нс)"=manual_latency)
plot(factor(buffer, levels=buffer), real_time, type="o", col="black", lty=0, ylim=c(-7786.592204891975, 66923.13440133378), xlab="", ylab="")
points(factor(buffer, levels=buffer), real_time, col="black", pch="o")
lines(factor(buffer, levels=buffer), real_time, col="black", lty=1, lwd=2)
title(main="Зависимость задержки от фактора", xlab="Размер буфера", ylab="Задержка (нс)")
points(factor(buffer, levels=buffer), cpu_time, col="red", pch="X")
lines(factor(buffer, levels=buffer), cpu_time, col="red", lty=2, lwd=2)
legend("bottomright", legend=c("Время отправки (нс)", "Время отправки CPU (нс)"), col=c("black", "red"), lty=c(1, 2), pch=c("o", "X"), ncol=1)

plot(factor(buffer, levels=buffer), bytes_per_second, type="o", col="black", lty=0, ylim=c(-11716244894.129612, 20425599728.336174), xlab="", ylab="")
points(factor(buffer, levels=buffer), bytes_per_second, col="black", pch="o")
lines(factor(buffer, levels=buffer), bytes_per_second, col="black", lty=1, lwd=2)
title(main="Зависимость широты пропускания от фактора", xlab="Размер буфера", ylab="Широта пропускания (байт/сек)")
text( factor(buffer, levels=buffer), bytes_per_second, labels=bytes_per_second, cex= 0.7, pos=3)
points(factor(buffer, levels=buffer), manual_bandwidth, col="red", pch="X")
lines(factor(buffer, levels=buffer), manual_bandwidth, col="red", lty=2, lwd=2)
text( factor(buffer, levels=buffer), manual_bandwidth, labels=manual_bandwidth, cex= 0.7, pos=3)
legend("bottomright", legend=c("Широта пропускания публикующего (б/с)", "Широта пропускания принимающего (б/с)"), col=c("black", "red"), lty=c(1, 2), pch=c("o", "X"), ncol=1)

Benchmark name is “PublisherFixture/ROS_BM_Publish_method” by var=buffer where subs_count=2 size=262144

#png(filename="plot.png", width = 1600, height = 900)
buffer <- c(1, 10, 100, 1000, 10000)
real_time <- c(138466.80334453724, 156678.52654583377, 118446.11124035002, 116784.93429238015, 118492.05242499604)
cpu_time <- c(129852.51859758081, 146432.22351725868, 112039.72276923378, 110091.70791835929, 110418.11147389459)
bytes_per_second <- c(3929260681.2738633, 3377772643.1434693, 4632655800.211837, 6262394445.192435, 5106005358.142822)
manual_bandwidth <- c(1104191718.8160434, 3473434842.778556, 1893473696.7061825, 2105065632.068996, 1237491098.9358497)
manual_latency <- c(80577364.41085295, 73459386.45098288, 83045250.55993205, 69250492.06501743, 77199931.33760805)
df <- data.frame("factor"=buffer, "Время отправки (нс)"=real_time, "Время отправки CPU (нс)"=cpu_time, "Широта пропускания публикующего (б/с)"=bytes_per_second, "Широта пропускания принимающего (б/с)"=manual_bandwidth, "Задержка передачи (нс)"=manual_latency)
plot(factor(buffer, levels=buffer), real_time, type="o", col="black", lty=0, ylim=c(-13727.223937996743, 280497.4584021898), xlab="", ylab="")
points(factor(buffer, levels=buffer), real_time, col="black", pch="o")
lines(factor(buffer, levels=buffer), real_time, col="black", lty=1, lwd=2)
title(main="Зависимость задержки от фактора", xlab="Размер буфера", ylab="Задержка (нс)")
points(factor(buffer, levels=buffer), cpu_time, col="red", pch="X")
lines(factor(buffer, levels=buffer), cpu_time, col="red", lty=2, lwd=2)
legend("bottomright", legend=c("Время отправки (нс)", "Время отправки CPU (нс)"), col=c("black", "red"), lty=c(1, 2), pch=c("o", "X"), ncol=1)

plot(factor(buffer, levels=buffer), bytes_per_second, type="o", col="black", lty=0, ylim=c(-6381969180.196925, 13748555344.205404), xlab="", ylab="")
points(factor(buffer, levels=buffer), bytes_per_second, col="black", pch="o")
lines(factor(buffer, levels=buffer), bytes_per_second, col="black", lty=1, lwd=2)
title(main="Зависимость широты пропускания от фактора", xlab="Размер буфера", ylab="Широта пропускания (байт/сек)")
text( factor(buffer, levels=buffer), bytes_per_second, labels=bytes_per_second, cex= 0.7, pos=3)
points(factor(buffer, levels=buffer), manual_bandwidth, col="red", pch="X")
lines(factor(buffer, levels=buffer), manual_bandwidth, col="red", lty=2, lwd=2)
text( factor(buffer, levels=buffer), manual_bandwidth, labels=manual_bandwidth, cex= 0.7, pos=3)
legend("bottomright", legend=c("Широта пропускания публикующего (б/с)", "Широта пропускания принимающего (б/с)"), col=c("black", "red"), lty=c(1, 2), pch=c("o", "X"), ncol=1)

Benchmark name is “PublisherFixture/ROS_BM_Publish_method” by var=buffer where subs_count=2 size=1048576

#png(filename="plot.png", width = 1600, height = 900)
buffer <- c(1, 10, 100, 1000, 10000)
real_time <- c(1049393.0118269408, 1062913.473846598, 1045177.2451610618, 1043647.9576920314, 1056295.8743406371)
cpu_time <- c(998608.2619041704, 1008077.2297174223, 977938.2818736115, 976763.3032344186, 1001880.9252224505)
bytes_per_second <- c(1999232016.0359528, 1973262041.9217057, 2008952571.5023131, 2011586122.5647187, 1985621035.2700417)
manual_bandwidth <- c(297587554.9579857, 315903457.72692543, 404496438.7546527, 555374458.9687614, 277874947.56378603)
manual_latency <- c(101937629.46190262, 102703338.59898433, 88118620.99615079, 82358254.74070504, 101509351.58627497)
df <- data.frame("factor"=buffer, "Время отправки (нс)"=real_time, "Время отправки CPU (нс)"=cpu_time, "Широта пропускания публикующего (б/с)"=bytes_per_second, "Широта пропускания принимающего (б/с)"=manual_bandwidth, "Задержка передачи (нс)"=manual_latency)
plot(factor(buffer, levels=buffer), real_time, type="o", col="black", lty=0, ylim=c(879664.2363556834, 1160012.5407253334), xlab="", ylab="")
points(factor(buffer, levels=buffer), real_time, col="black", pch="o")
lines(factor(buffer, levels=buffer), real_time, col="black", lty=1, lwd=2)
title(main="Зависимость задержки от фактора", xlab="Размер буфера", ylab="Задержка (нс)")
points(factor(buffer, levels=buffer), cpu_time, col="red", pch="X")
lines(factor(buffer, levels=buffer), cpu_time, col="red", lty=2, lwd=2)
legend("bottomright", legend=c("Время отправки (нс)", "Время отправки CPU (нс)"), col=c("black", "red"), lty=c(1, 2), pch=c("o", "X"), ncol=1)

plot(factor(buffer, levels=buffer), bytes_per_second, type="o", col="black", lty=0, ylim=c(-904386559.1952221, 3193847629.323727), xlab="", ylab="")
points(factor(buffer, levels=buffer), bytes_per_second, col="black", pch="o")
lines(factor(buffer, levels=buffer), bytes_per_second, col="black", lty=1, lwd=2)
title(main="Зависимость широты пропускания от фактора", xlab="Размер буфера", ylab="Широта пропускания (байт/сек)")
text( factor(buffer, levels=buffer), bytes_per_second, labels=bytes_per_second, cex= 0.7, pos=3)
points(factor(buffer, levels=buffer), manual_bandwidth, col="red", pch="X")
lines(factor(buffer, levels=buffer), manual_bandwidth, col="red", lty=2, lwd=2)
text( factor(buffer, levels=buffer), manual_bandwidth, labels=manual_bandwidth, cex= 0.7, pos=3)
legend("bottomright", legend=c("Широта пропускания публикующего (б/с)", "Широта пропускания принимающего (б/с)"), col=c("black", "red"), lty=c(1, 2), pch=c("o", "X"), ncol=1)

Benchmark name is “PublisherFixture/ROS_BM_Publish_method” by var=buffer where subs_count=2 size=4194304

#png(filename="plot.png", width = 1600, height = 900)
buffer <- c(1, 10, 100, 1000, 10000)
real_time <- c(2557254.6511730812, 2448094.834862402, 2315141.7616982264, 2359972.559685654, 2039001.39545636)
cpu_time <- c(2528496.416431994, 2410404.031687948, 2273895.2883129334, 2311370.5142863803, 2020847.947879585)
bytes_per_second <- c(4849990870.313324, 4865094016.236982, 5910106222.714949, 5012215604.68105, 6158570988.034955)
manual_bandwidth <- c(43486142.14427169, 51878344.542379335, 46890340.817584045, 46795938.886254385, 52337303.617246225)
manual_latency <- c(596726049.9999999, 472805668.7499999, 342137895.0, 421625248.225, 443514995.05)
df <- data.frame("factor"=buffer, "Время отправки (нс)"=real_time, "Время отправки CPU (нс)"=cpu_time, "Широта пропускания публикующего (б/с)"=bytes_per_second, "Широта пропускания принимающего (б/с)"=manual_bandwidth, "Задержка передачи (нс)"=manual_latency)
plot(factor(buffer, levels=buffer), real_time, type="o", col="black", lty=0, ylim=c(-467116.38140207133, 5045218.980454737), xlab="", ylab="")
points(factor(buffer, levels=buffer), real_time, col="black", pch="o")
lines(factor(buffer, levels=buffer), real_time, col="black", lty=1, lwd=2)
title(main="Зависимость задержки от фактора", xlab="Размер буфера", ylab="Задержка (нс)")
points(factor(buffer, levels=buffer), cpu_time, col="red", pch="X")
lines(factor(buffer, levels=buffer), cpu_time, col="red", lty=2, lwd=2)
legend("bottomright", legend=c("Время отправки (нс)", "Время отправки CPU (нс)"), col=c("black", "red"), lty=c(1, 2), pch=c("o", "X"), ncol=1)

plot(factor(buffer, levels=buffer), bytes_per_second, type="o", col="black", lty=0, ylim=c(-9105861153.141468, 15307918283.320696), xlab="", ylab="")
points(factor(buffer, levels=buffer), bytes_per_second, col="black", pch="o")
lines(factor(buffer, levels=buffer), bytes_per_second, col="black", lty=1, lwd=2)
title(main="Зависимость широты пропускания от фактора", xlab="Размер буфера", ylab="Широта пропускания (байт/сек)")
text( factor(buffer, levels=buffer), bytes_per_second, labels=bytes_per_second, cex= 0.7, pos=3)
points(factor(buffer, levels=buffer), manual_bandwidth, col="red", pch="X")
lines(factor(buffer, levels=buffer), manual_bandwidth, col="red", lty=2, lwd=2)
text( factor(buffer, levels=buffer), manual_bandwidth, labels=manual_bandwidth, cex= 0.7, pos=3)
legend("bottomright", legend=c("Широта пропускания публикующего (б/с)", "Широта пропускания принимающего (б/с)"), col=c("black", "red"), lty=c(1, 2), pch=c("o", "X"), ncol=1)

Benchmark name is “PublisherFixture/ROS_BM_Publish_method” by var=buffer where subs_count=2 size=16777216

#png(filename="plot.png", width = 1600, height = 900)
buffer <- c(1, 10, 100, 1000, 10000)
real_time <- c(22559426.36559212, 22561735.027286913, 22355699.803196214, 22414016.296895057, 22575119.67813741)
cpu_time <- c(21285161.103121914, 21388009.081821375, 21274983.38709595, 21266647.921870433, 21325079.599998984)
bytes_per_second <- c(1487469904.2389154, 1487560472.1948926, 1501298809.8137298, 1497391531.0611567, 1486570954.332946)
manual_bandwidth <- c(66693479.00302472, 57474150.51280172, 51800864.92281709, 50552285.35404814, 62585798.89146529)
manual_latency <- c(1008205188.7, 1075517916.8, 1129658543.0, 992827572.75, 1032681598.45)
df <- data.frame("factor"=buffer, "Время отправки (нс)"=real_time, "Время отправки CPU (нс)"=cpu_time, "Широта пропускания публикующего (б/с)"=bytes_per_second, "Широта пропускания принимающего (б/с)"=manual_bandwidth, "Задержка передачи (нс)"=manual_latency)
plot(factor(buffer, levels=buffer), real_time, type="o", col="black", lty=0, ylim=c(20084659.28550041, 23757108.314507432), xlab="", ylab="")
points(factor(buffer, levels=buffer), real_time, col="black", pch="o")
lines(factor(buffer, levels=buffer), real_time, col="black", lty=1, lwd=2)
title(main="Зависимость задержки от фактора", xlab="Размер буфера", ylab="Задержка (нс)")
points(factor(buffer, levels=buffer), cpu_time, col="red", pch="X")
lines(factor(buffer, levels=buffer), cpu_time, col="red", lty=2, lwd=2)
legend("bottomright", legend=c("Время отправки (нс)", "Время отправки CPU (нс)"), col=c("black", "red"), lty=c(1, 2), pch=c("o", "X"), ncol=1)

plot(factor(buffer, levels=buffer), bytes_per_second, type="o", col="black", lty=0, ylim=c(-710650094.0761889, 2262501189.243967), xlab="", ylab="")
points(factor(buffer, levels=buffer), bytes_per_second, col="black", pch="o")
lines(factor(buffer, levels=buffer), bytes_per_second, col="black", lty=1, lwd=2)
title(main="Зависимость широты пропускания от фактора", xlab="Размер буфера", ylab="Широта пропускания (байт/сек)")
text( factor(buffer, levels=buffer), bytes_per_second, labels=bytes_per_second, cex= 0.7, pos=3)
points(factor(buffer, levels=buffer), manual_bandwidth, col="red", pch="X")
lines(factor(buffer, levels=buffer), manual_bandwidth, col="red", lty=2, lwd=2)
text( factor(buffer, levels=buffer), manual_bandwidth, labels=manual_bandwidth, cex= 0.7, pos=3)
legend("bottomright", legend=c("Широта пропускания публикующего (б/с)", "Широта пропускания принимающего (б/с)"), col=c("black", "red"), lty=c(1, 2), pch=c("o", "X"), ncol=1)

Benchmark name is “PublisherFixture/ROS_BM_Publish_method” by var=buffer where subs_count=2 size=67108864

#png(filename="plot.png", width = 1600, height = 900)
buffer <- c(1, 10, 100, 1000, 10000)
real_time <- c(89927750.20001318, 90571704.1999992, 88680996.94998363, 89716667.31254117, 89915839.62508684)
cpu_time <- c(85783181.7124989, 85892568.46249923, 86191063.26250406, 85706402.67500095, 86114938.05000237)
bytes_per_second <- c(1492840055.6196458, 1481918626.544727, 1514139480.1089492, 1496490513.9038959, 1493074867.8146243)
manual_bandwidth <- c(39672064.81443493, 34573926.6295575, 34611524.52859531, 34607090.33394261, 27468889.404516257)
manual_latency <- c(3799002010.5, 3884474346.9, 3880524864.1, 3880976503.3, 3127171751.1)
df <- data.frame("factor"=buffer, "Время отправки (нс)"=real_time, "Время отправки CPU (нс)"=cpu_time, "Широта пропускания публикующего (б/с)"=bytes_per_second, "Широта пропускания принимающего (б/с)"=manual_bandwidth, "Задержка передачи (нс)"=manual_latency)
plot(factor(buffer, levels=buffer), real_time, type="o", col="black", lty=0, ylim=c(80515050.47899123, 95763056.39600892), xlab="", ylab="")
points(factor(buffer, levels=buffer), real_time, col="black", pch="o")
lines(factor(buffer, levels=buffer), real_time, col="black", lty=1, lwd=2)
title(main="Зависимость задержки от фактора", xlab="Размер буфера", ylab="Задержка (нс)")
points(factor(buffer, levels=buffer), cpu_time, col="red", pch="X")
lines(factor(buffer, levels=buffer), cpu_time, col="red", lty=2, lwd=2)
legend("bottomright", legend=c("Время отправки (нс)", "Время отправки CPU (нс)"), col=c("black", "red"), lty=c(1, 2), pch=c("o", "X"), ncol=1)

plot(factor(buffer, levels=buffer), bytes_per_second, type="o", col="black", lty=0, ylim=c(-763409752.825451, 2305018122.338917), xlab="", ylab="")
points(factor(buffer, levels=buffer), bytes_per_second, col="black", pch="o")
lines(factor(buffer, levels=buffer), bytes_per_second, col="black", lty=1, lwd=2)
title(main="Зависимость широты пропускания от фактора", xlab="Размер буфера", ylab="Широта пропускания (байт/сек)")
text( factor(buffer, levels=buffer), bytes_per_second, labels=bytes_per_second, cex= 0.7, pos=3)
points(factor(buffer, levels=buffer), manual_bandwidth, col="red", pch="X")
lines(factor(buffer, levels=buffer), manual_bandwidth, col="red", lty=2, lwd=2)
text( factor(buffer, levels=buffer), manual_bandwidth, labels=manual_bandwidth, cex= 0.7, pos=3)
legend("bottomright", legend=c("Широта пропускания публикующего (б/с)", "Широта пропускания принимающего (б/с)"), col=c("black", "red"), lty=c(1, 2), pch=c("o", "X"), ncol=1)

Benchmark name is “PublisherFixture/ROS_BM_Publish_method” by var=buffer where subs_count=4 size=1024

#png(filename="plot.png", width = 1600, height = 900)
buffer <- c(1, 10, 100, 1000, 10000)
real_time <- c(4684.410036701205, 4605.697632950371, 4624.482520685689, 4712.889624609076, 4587.953994373003)
cpu_time <- c(3339.426264617111, 3347.2170040059764, 3307.0349335376313, 3370.339144370778, 3237.9827143256225)
bytes_per_second <- c(874634945.652821, 889338766.6675043, 885769097.0603113, 869127377.0770099, 892897826.9535488)
manual_bandwidth <- c(33317737593.986713, 38957175762.18716, 27310638125.28106, 23581343245.885048, 16273678924.709589)
manual_latency <- c(3587458.8356091543, 2653355.2797045363, 6639831.718454286, 6253900.006806096, 20032105.41607633)
df <- data.frame("factor"=buffer, "Время отправки (нс)"=real_time, "Время отправки CPU (нс)"=cpu_time, "Широта пропускания публикующего (б/с)"=bytes_per_second, "Широта пропускания принимающего (б/с)"=manual_bandwidth, "Задержка передачи (нс)"=manual_latency)
plot(factor(buffer, levels=buffer), real_time, type="o", col="black", lty=0, ylim=c(2379.934808144322, 5570.9375307903765), xlab="", ylab="")
points(factor(buffer, levels=buffer), real_time, col="black", pch="o")
lines(factor(buffer, levels=buffer), real_time, col="black", lty=1, lwd=2)
title(main="Зависимость задержки от фактора", xlab="Размер буфера", ylab="Задержка (нс)")
points(factor(buffer, levels=buffer), cpu_time, col="red", pch="X")
lines(factor(buffer, levels=buffer), cpu_time, col="red", lty=2, lwd=2)
legend("bottomright", legend=c("Время отправки (нс)", "Время отправки CPU (нс)"), col=c("black", "red"), lty=c(1, 2), pch=c("o", "X"), ncol=1)

plot(factor(buffer, levels=buffer), bytes_per_second, type="o", col="black", lty=0, ylim=c(-36535909363.531586, 76362212502.79575), xlab="", ylab="")
points(factor(buffer, levels=buffer), bytes_per_second, col="black", pch="o")
lines(factor(buffer, levels=buffer), bytes_per_second, col="black", lty=1, lwd=2)
title(main="Зависимость широты пропускания от фактора", xlab="Размер буфера", ylab="Широта пропускания (байт/сек)")
text( factor(buffer, levels=buffer), bytes_per_second, labels=bytes_per_second, cex= 0.7, pos=3)
points(factor(buffer, levels=buffer), manual_bandwidth, col="red", pch="X")
lines(factor(buffer, levels=buffer), manual_bandwidth, col="red", lty=2, lwd=2)
text( factor(buffer, levels=buffer), manual_bandwidth, labels=manual_bandwidth, cex= 0.7, pos=3)
legend("bottomright", legend=c("Широта пропускания публикующего (б/с)", "Широта пропускания принимающего (б/с)"), col=c("black", "red"), lty=c(1, 2), pch=c("o", "X"), ncol=1)

Benchmark name is “PublisherFixture/ROS_BM_Publish_method” by var=buffer where subs_count=4 size=4096

#png(filename="plot.png", width = 1600, height = 900)
buffer <- c(1, 10, 100, 1000, 10000)
real_time <- c(5346.713790906761, 5367.284222920496, 5399.78996214403, 5361.902088942925, 5370.790820216232)
cpu_time <- c(4312.555429542455, 4326.7471633898185, 4343.02291016358, 4306.291444705461, 4327.178122762954)
bytes_per_second <- c(3064724132.7861276, 3053003432.596627, 3034455990.8642945, 3055941645.1282587, 3050739653.3870015)
manual_bandwidth <- c(2329416068.3462152, 2381763236.2732363, 2033944234.4771824, 2289535860.949351, 2156300520.061728)
manual_latency <- c(69984912.93569992, 71100658.07463613, 64148483.550389096, 71400029.05294092, 64072438.99136543)
df <- data.frame("factor"=buffer, "Время отправки (нс)"=real_time, "Время отправки CPU (нс)"=cpu_time, "Широта пропускания публикующего (б/с)"=bytes_per_second, "Широта пропускания принимающего (б/с)"=manual_bandwidth, "Задержка передачи (нс)"=manual_latency)
plot(factor(buffer, levels=buffer), real_time, type="o", col="black", lty=0, ylim=c(3662.5396573678154, 6043.541749481676), xlab="", ylab="")
points(factor(buffer, levels=buffer), real_time, col="black", pch="o")
lines(factor(buffer, levels=buffer), real_time, col="black", lty=1, lwd=2)
title(main="Зависимость задержки от фактора", xlab="Размер буфера", ylab="Задержка (нс)")
points(factor(buffer, levels=buffer), cpu_time, col="red", pch="X")
lines(factor(buffer, levels=buffer), cpu_time, col="red", lty=2, lwd=2)
legend("bottomright", legend=c("Время отправки (нс)", "Время отправки CPU (нс)"), col=c("black", "red"), lty=c(1, 2), pch=c("o", "X"), ncol=1)

plot(factor(buffer, levels=buffer), bytes_per_second, type="o", col="black", lty=0, ylim=c(1174233597.5864768, 3924434769.676833), xlab="", ylab="")
points(factor(buffer, levels=buffer), bytes_per_second, col="black", pch="o")
lines(factor(buffer, levels=buffer), bytes_per_second, col="black", lty=1, lwd=2)
title(main="Зависимость широты пропускания от фактора", xlab="Размер буфера", ylab="Широта пропускания (байт/сек)")
text( factor(buffer, levels=buffer), bytes_per_second, labels=bytes_per_second, cex= 0.7, pos=3)
points(factor(buffer, levels=buffer), manual_bandwidth, col="red", pch="X")
lines(factor(buffer, levels=buffer), manual_bandwidth, col="red", lty=2, lwd=2)
text( factor(buffer, levels=buffer), manual_bandwidth, labels=manual_bandwidth, cex= 0.7, pos=3)
legend("bottomright", legend=c("Широта пропускания публикующего (б/с)", "Широта пропускания принимающего (б/с)"), col=c("black", "red"), lty=c(1, 2), pch=c("o", "X"), ncol=1)

Benchmark name is “PublisherFixture/ROS_BM_Publish_method” by var=buffer where subs_count=4 size=16384

#png(filename="plot.png", width = 1600, height = 900)
buffer <- c(1, 10, 100, 1000, 10000)
real_time <- c(12739.164268983752, 8369.486783418668, 9490.150547117206, 10752.269587540362, 9245.790448701935)
cpu_time <- c(11534.677806046744, 7545.14963636342, 8535.646722518413, 9725.664769400386, 8384.418419042242)
bytes_per_second <- c(5240856404.250961, 7923108962.661034, 7128254019.550135, 6292109405.968262, 7115003107.011942)
manual_bandwidth <- c(13475766682.934181, 11314477975.625984, 15768120639.365692, 20973582784.367477, 34989820869.9505)
manual_latency <- c(3373828.0174958035, 20053693.589383326, 18481973.565961625, 7365034.737198986, 2647378.1340222927)
df <- data.frame("factor"=buffer, "Время отправки (нс)"=real_time, "Время отправки CPU (нс)"=cpu_time, "Широта пропускания публикующего (б/с)"=bytes_per_second, "Широта пропускания принимающего (б/с)"=manual_bandwidth, "Задержка передачи (нс)"=manual_latency)
plot(factor(buffer, levels=buffer), real_time, type="o", col="black", lty=0, ylim=c(1856.8167770697055, 18427.497128277464), xlab="", ylab="")
points(factor(buffer, levels=buffer), real_time, col="black", pch="o")
lines(factor(buffer, levels=buffer), real_time, col="black", lty=1, lwd=2)
title(main="Зависимость задержки от фактора", xlab="Размер буфера", ylab="Задержка (нс)")
points(factor(buffer, levels=buffer), cpu_time, col="red", pch="X")
lines(factor(buffer, levels=buffer), cpu_time, col="red", lty=2, lwd=2)
legend("bottomright", legend=c("Время отправки (нс)", "Время отправки CPU (нс)"), col=c("black", "red"), lty=c(1, 2), pch=c("o", "X"), ncol=1)

plot(factor(buffer, levels=buffer), bytes_per_second, type="o", col="black", lty=0, ylim=c(-24980381598.107246, 65211058872.30871), xlab="", ylab="")
points(factor(buffer, levels=buffer), bytes_per_second, col="black", pch="o")
lines(factor(buffer, levels=buffer), bytes_per_second, col="black", lty=1, lwd=2)
title(main="Зависимость широты пропускания от фактора", xlab="Размер буфера", ylab="Широта пропускания (байт/сек)")
text( factor(buffer, levels=buffer), bytes_per_second, labels=bytes_per_second, cex= 0.7, pos=3)
points(factor(buffer, levels=buffer), manual_bandwidth, col="red", pch="X")
lines(factor(buffer, levels=buffer), manual_bandwidth, col="red", lty=2, lwd=2)
text( factor(buffer, levels=buffer), manual_bandwidth, labels=manual_bandwidth, cex= 0.7, pos=3)
legend("bottomright", legend=c("Широта пропускания публикующего (б/с)", "Широта пропускания принимающего (б/с)"), col=c("black", "red"), lty=c(1, 2), pch=c("o", "X"), ncol=1)

Benchmark name is “PublisherFixture/ROS_BM_Publish_method” by var=buffer where subs_count=4 size=65536

#png(filename="plot.png", width = 1600, height = 900)
buffer <- c(1, 10, 100, 1000, 10000)
real_time <- c(29944.50241370626, 27571.602306367615, 34644.16481699764, 36526.00896665214, 27265.91673362119)
cpu_time <- c(28100.971902250858, 25937.902090064883, 32319.58201020346, 34106.24228974003, 25648.98542756456)
bytes_per_second <- c(9217878181.176826, 10078705939.816374, 7833252639.021375, 7254261781.212016, 10482922214.487345)
manual_bandwidth <- c(14011257059.91748, 5530105923.034509, 9560131902.1992, 11418274712.35957, 7309314599.778905)
manual_latency <- c(33114581.10933975, 42154147.876311064, 19961973.998794958, 16673952.391487712, 37669459.2848752)
df <- data.frame("factor"=buffer, "Время отправки (нс)"=real_time, "Время отправки CPU (нс)"=cpu_time, "Широта пропускания публикующего (б/с)"=bytes_per_second, "Широта пропускания принимающего (б/с)"=manual_bandwidth, "Задержка передачи (нс)"=manual_latency)
plot(factor(buffer, levels=buffer), real_time, type="o", col="black", lty=0, ylim=c(8832.015209011013, 53342.97918520569), xlab="", ylab="")
points(factor(buffer, levels=buffer), real_time, col="black", pch="o")
lines(factor(buffer, levels=buffer), real_time, col="black", lty=1, lwd=2)
title(main="Зависимость задержки от фактора", xlab="Размер буфера", ylab="Задержка (нс)")
points(factor(buffer, levels=buffer), cpu_time, col="red", pch="X")
lines(factor(buffer, levels=buffer), cpu_time, col="red", lty=2, lwd=2)
legend("bottomright", legend=c("Время отправки (нс)", "Время отправки CPU (нс)"), col=c("black", "red"), lty=c(1, 2), pch=c("o", "X"), ncol=1)

plot(factor(buffer, levels=buffer), bytes_per_second, type="o", col="black", lty=0, ylim=c(-16604448075.450935, 36145811058.40292), xlab="", ylab="")
points(factor(buffer, levels=buffer), bytes_per_second, col="black", pch="o")
lines(factor(buffer, levels=buffer), bytes_per_second, col="black", lty=1, lwd=2)
title(main="Зависимость широты пропускания от фактора", xlab="Размер буфера", ylab="Широта пропускания (байт/сек)")
text( factor(buffer, levels=buffer), bytes_per_second, labels=bytes_per_second, cex= 0.7, pos=3)
points(factor(buffer, levels=buffer), manual_bandwidth, col="red", pch="X")
lines(factor(buffer, levels=buffer), manual_bandwidth, col="red", lty=2, lwd=2)
text( factor(buffer, levels=buffer), manual_bandwidth, labels=manual_bandwidth, cex= 0.7, pos=3)
legend("bottomright", legend=c("Широта пропускания публикующего (б/с)", "Широта пропускания принимающего (б/с)"), col=c("black", "red"), lty=c(1, 2), pch=c("o", "X"), ncol=1)

Benchmark name is “PublisherFixture/ROS_BM_Publish_method” by var=buffer where subs_count=4 size=262144

#png(filename="plot.png", width = 1600, height = 900)
buffer <- c(1, 10, 100, 1000, 10000)
real_time <- c(86679.54204052503, 210490.30252709132, 134070.25446016068, 167898.01963332348, 149781.32933947368)
cpu_time <- c(82794.52101032724, 193232.61614858796, 124878.06475391709, 155198.68818133732, 138081.84668269302)
bytes_per_second <- c(12849323610.198, 5124425685.3186455, 9851014823.972012, 6435647074.575093, 8588301194.865343)
manual_bandwidth <- c(2259050407.348436, 3275857905.639853, 5994457919.501843, 3571684890.2738266, 1755849440.5081794)
manual_latency <- c(86140909.76873703, 41921718.62008665, 71624033.75718684, 74279493.43260616, 75645148.86241046)
df <- data.frame("factor"=buffer, "Время отправки (нс)"=real_time, "Время отправки CPU (нс)"=cpu_time, "Широта пропускания публикующего (б/с)"=bytes_per_second, "Широта пропускания принимающего (б/с)"=manual_bandwidth, "Задержка передачи (нс)"=manual_latency)
plot(factor(buffer, levels=buffer), real_time, type="o", col="black", lty=0, ylim=c(-76664.84574867322, 369949.6692860918), xlab="", ylab="")
points(factor(buffer, levels=buffer), real_time, col="black", pch="o")
lines(factor(buffer, levels=buffer), real_time, col="black", lty=1, lwd=2)
title(main="Зависимость задержки от фактора", xlab="Размер буфера", ylab="Задержка (нс)")
points(factor(buffer, levels=buffer), cpu_time, col="red", pch="X")
lines(factor(buffer, levels=buffer), cpu_time, col="red", lty=2, lwd=2)
legend("bottomright", legend=c("Время отправки (нс)", "Время отправки CPU (нс)"), col=c("black", "red"), lty=c(1, 2), pch=c("o", "X"), ncol=1)

plot(factor(buffer, levels=buffer), bytes_per_second, type="o", col="black", lty=0, ylim=c(-11636802036.38053, 26241975087.086708), xlab="", ylab="")
points(factor(buffer, levels=buffer), bytes_per_second, col="black", pch="o")
lines(factor(buffer, levels=buffer), bytes_per_second, col="black", lty=1, lwd=2)
title(main="Зависимость широты пропускания от фактора", xlab="Размер буфера", ylab="Широта пропускания (байт/сек)")
text( factor(buffer, levels=buffer), bytes_per_second, labels=bytes_per_second, cex= 0.7, pos=3)
points(factor(buffer, levels=buffer), manual_bandwidth, col="red", pch="X")
lines(factor(buffer, levels=buffer), manual_bandwidth, col="red", lty=2, lwd=2)
text( factor(buffer, levels=buffer), manual_bandwidth, labels=manual_bandwidth, cex= 0.7, pos=3)
legend("bottomright", legend=c("Широта пропускания публикующего (б/с)", "Широта пропускания принимающего (б/с)"), col=c("black", "red"), lty=c(1, 2), pch=c("o", "X"), ncol=1)

Benchmark name is “PublisherFixture/ROS_BM_Publish_method” by var=buffer where subs_count=4 size=1048576

#png(filename="plot.png", width = 1600, height = 900)
buffer <- c(1, 10, 100, 1000, 10000)
real_time <- c(1019453.1587962955, 1053547.9085778226, 1008150.0168363571, 1065363.2333856323, 1057543.882882535)
cpu_time <- c(946961.6993996624, 983041.5359255284, 946257.5054398484, 1011206.7681832307, 1005631.0280327635)
bytes_per_second <- c(4126594766.9789224, 3982054647.796869, 4191437308.220475, 3940250242.7986403, 3967768007.405999)
manual_bandwidth <- c(1611068316.3186483, 903666628.6355705, 1090334610.9008038, 487172300.56533176, 530392484.89424354)
manual_latency <- c(82817313.55019698, 90803610.58428074, 91138186.48844936, 139895687.1297222, 92438736.00555554)
df <- data.frame("factor"=buffer, "Время отправки (нс)"=real_time, "Время отправки CPU (нс)"=cpu_time, "Широта пропускания публикующего (б/с)"=bytes_per_second, "Широта пропускания принимающего (б/с)"=manual_bandwidth, "Задержка передачи (нс)"=manual_latency)
plot(factor(buffer, levels=buffer), real_time, type="o", col="black", lty=0, ylim=c(763649.264344633, 1247971.4744808478), xlab="", ylab="")
points(factor(buffer, levels=buffer), real_time, col="black", pch="o")
lines(factor(buffer, levels=buffer), real_time, col="black", lty=1, lwd=2)
title(main="Зависимость задержки от фактора", xlab="Размер буфера", ylab="Задержка (нс)")
points(factor(buffer, levels=buffer), cpu_time, col="red", pch="X")
lines(factor(buffer, levels=buffer), cpu_time, col="red", lty=2, lwd=2)
legend("bottomright", legend=c("Время отправки (нс)", "Время отправки CPU (нс)"), col=c("black", "red"), lty=c(1, 2), pch=c("o", "X"), ncol=1)

plot(factor(buffer, levels=buffer), bytes_per_second, type="o", col="black", lty=0, ylim=c(-2026296137.8123949, 6704905746.598202), xlab="", ylab="")
points(factor(buffer, levels=buffer), bytes_per_second, col="black", pch="o")
lines(factor(buffer, levels=buffer), bytes_per_second, col="black", lty=1, lwd=2)
title(main="Зависимость широты пропускания от фактора", xlab="Размер буфера", ylab="Широта пропускания (байт/сек)")
text( factor(buffer, levels=buffer), bytes_per_second, labels=bytes_per_second, cex= 0.7, pos=3)
points(factor(buffer, levels=buffer), manual_bandwidth, col="red", pch="X")
lines(factor(buffer, levels=buffer), manual_bandwidth, col="red", lty=2, lwd=2)
text( factor(buffer, levels=buffer), manual_bandwidth, labels=manual_bandwidth, cex= 0.7, pos=3)
legend("bottomright", legend=c("Широта пропускания публикующего (б/с)", "Широта пропускания принимающего (б/с)"), col=c("black", "red"), lty=c(1, 2), pch=c("o", "X"), ncol=1)

Benchmark name is “PublisherFixture/ROS_BM_Publish_method” by var=buffer where subs_count=4 size=4194304

#png(filename="plot.png", width = 1600, height = 900)
buffer <- c(1, 10, 100, 1000, 10000)
real_time <- c(2207735.459279661, 2015943.2467647314, 1995241.8501838427, 1862110.5648453697, 1396115.5897024714)
cpu_time <- c(2146591.974364406, 1980392.9275694578, 1960510.2177928023, 1807315.7705451879, 1368306.8562658033)
bytes_per_second <- c(9073821024.198309, 10838747136.070347, 9565382380.90919, 11731203931.272608, 12678530426.041998)
manual_bandwidth <- c(107360186.24234459, 112091357.4218053, 147367059.01183873, 180829248.2683262, 251041516.35877603)
manual_latency <- c(619456585.3566667, 435758229.1333333, 443972059.35999995, 365490733.16833335, 269597561.4666667)
df <- data.frame("factor"=buffer, "Время отправки (нс)"=real_time, "Время отправки CPU (нс)"=cpu_time, "Широта пропускания публикующего (б/с)"=bytes_per_second, "Широта пропускания принимающего (б/с)"=manual_bandwidth, "Задержка передачи (нс)"=manual_latency)
plot(factor(buffer, levels=buffer), real_time, type="o", col="black", lty=0, ylim=c(-641974.7837593098, 4218017.099304775), xlab="", ylab="")
points(factor(buffer, levels=buffer), real_time, col="black", pch="o")
lines(factor(buffer, levels=buffer), real_time, col="black", lty=1, lwd=2)
title(main="Зависимость задержки от фактора", xlab="Размер буфера", ylab="Задержка (нс)")
points(factor(buffer, levels=buffer), cpu_time, col="red", pch="X")
lines(factor(buffer, levels=buffer), cpu_time, col="red", lty=2, lwd=2)
legend("bottomright", legend=c("Время отправки (нс)", "Время отправки CPU (нс)"), col=c("black", "red"), lty=c(1, 2), pch=c("o", "X"), ncol=1)

plot(factor(buffer, levels=buffer), bytes_per_second, type="o", col="black", lty=0, ylim=c(-14828462510.95249, 27614353123.23683), xlab="", ylab="")
points(factor(buffer, levels=buffer), bytes_per_second, col="black", pch="o")
lines(factor(buffer, levels=buffer), bytes_per_second, col="black", lty=1, lwd=2)
title(main="Зависимость широты пропускания от фактора", xlab="Размер буфера", ylab="Широта пропускания (байт/сек)")
text( factor(buffer, levels=buffer), bytes_per_second, labels=bytes_per_second, cex= 0.7, pos=3)
points(factor(buffer, levels=buffer), manual_bandwidth, col="red", pch="X")
lines(factor(buffer, levels=buffer), manual_bandwidth, col="red", lty=2, lwd=2)
text( factor(buffer, levels=buffer), manual_bandwidth, labels=manual_bandwidth, cex= 0.7, pos=3)
legend("bottomright", legend=c("Широта пропускания публикующего (б/с)", "Широта пропускания принимающего (б/с)"), col=c("black", "red"), lty=c(1, 2), pch=c("o", "X"), ncol=1)

Benchmark name is “PublisherFixture/ROS_BM_Publish_method” by var=buffer where subs_count=4 size=16777216

#png(filename="plot.png", width = 1600, height = 900)
buffer <- c(1, 10, 100, 1000, 10000)
real_time <- c(23292156.30967273, 23504962.296752755, 23068276.403340254, 23347286.599988975, 23305184.95172296)
cpu_time <- c(21914477.358061578, 22159873.264530275, 21873380.620002083, 22050606.196670894, 21952144.58275696)
bytes_per_second <- c(2881641092.722139, 2856000457.834505, 2909598738.8389, 2874616568.07146, 2880529515.95339)
manual_bandwidth <- c(133697911.92292611, 133653012.92550774, 130036593.07107392, 124018878.37218018, 104369022.20619102)
manual_latency <- c(1005167778.25, 1005367566.55, 1032974701.15, 1032704555.4, 1106952711.4)
df <- data.frame("factor"=buffer, "Время отправки (нс)"=real_time, "Время отправки CPU (нс)"=cpu_time, "Широта пропускания публикующего (б/с)"=bytes_per_second, "Широта пропускания принимающего (б/с)"=manual_bandwidth, "Задержка передачи (нс)"=manual_latency)
plot(factor(buffer, levels=buffer), real_time, type="o", col="black", lty=0, ylim=c(20426978.078462534, 24951364.838292304), xlab="", ylab="")
points(factor(buffer, levels=buffer), real_time, col="black", pch="o")
lines(factor(buffer, levels=buffer), real_time, col="black", lty=1, lwd=2)
title(main="Зависимость задержки от фактора", xlab="Размер буфера", ylab="Задержка (нс)")
points(factor(buffer, levels=buffer), cpu_time, col="red", pch="X")
lines(factor(buffer, levels=buffer), cpu_time, col="red", lty=2, lwd=2)
legend("bottomright", legend=c("Время отправки (нс)", "Время отправки CPU (нс)"), col=c("black", "red"), lty=c(1, 2), pch=c("o", "X"), ncol=1)

plot(factor(buffer, levels=buffer), bytes_per_second, type="o", col="black", lty=0, ylim=c(-1379071428.0603926, 4393039189.105484), xlab="", ylab="")
points(factor(buffer, levels=buffer), bytes_per_second, col="black", pch="o")
lines(factor(buffer, levels=buffer), bytes_per_second, col="black", lty=1, lwd=2)
title(main="Зависимость широты пропускания от фактора", xlab="Размер буфера", ylab="Широта пропускания (байт/сек)")
text( factor(buffer, levels=buffer), bytes_per_second, labels=bytes_per_second, cex= 0.7, pos=3)
points(factor(buffer, levels=buffer), manual_bandwidth, col="red", pch="X")
lines(factor(buffer, levels=buffer), manual_bandwidth, col="red", lty=2, lwd=2)
text( factor(buffer, levels=buffer), manual_bandwidth, labels=manual_bandwidth, cex= 0.7, pos=3)
legend("bottomright", legend=c("Широта пропускания публикующего (б/с)", "Широта пропускания принимающего (б/с)"), col=c("black", "red"), lty=c(1, 2), pch=c("o", "X"), ncol=1)

Benchmark name is “PublisherFixture/ROS_BM_Publish_method” by var=buffer where subs_count=4 size=67108864

#png(filename="plot.png", width = 1600, height = 900)
buffer <- c(1, 10, 100, 1000, 10000)
real_time <- c(93498160.96246286, 91232388.98746423, 92551044.3624944, 92941189.26244438, 93057628.11248997)
cpu_time <- c(88778417.11252189, 87516438.4750036, 88371835.92498264, 88493378.37500286, 87969822.2874964)
bytes_per_second <- c(2872424553.5251665, 2944440941.3977957, 2902150669.535243, 2888397199.7083015, 2884831442.8780107)
manual_bandwidth <- c(76775254.21171837, 67084073.830885425, 66992589.310907885, 67168469.40286735, 53351514.60043373)
manual_latency <- c(3926255453.55, 4003217457.1, 4008701339.4, 3998641182.8, 3220132418.9)
df <- data.frame("factor"=buffer, "Время отправки (нс)"=real_time, "Время отправки CPU (нс)"=cpu_time, "Широта пропускания публикующего (б/с)"=bytes_per_second, "Широта пропускания принимающего (б/с)"=manual_bandwidth, "Задержка передачи (нс)"=manual_latency)
plot(factor(buffer, levels=buffer), real_time, type="o", col="black", lty=0, ylim=c(80892475.60533568, 100122123.83213077), xlab="", ylab="")
points(factor(buffer, levels=buffer), real_time, col="black", pch="o")
lines(factor(buffer, levels=buffer), real_time, col="black", lty=1, lwd=2)
title(main="Зависимость задержки от фактора", xlab="Размер буфера", ylab="Задержка (нс)")
points(factor(buffer, levels=buffer), cpu_time, col="red", pch="X")
lines(factor(buffer, levels=buffer), cpu_time, col="red", lty=2, lwd=2)
legend("bottomright", legend=c("Время отправки (нс)", "Время отправки CPU (нс)"), col=c("black", "red"), lty=c(1, 2), pch=c("o", "X"), ncol=1)

plot(factor(buffer, levels=buffer), bytes_per_second, type="o", col="black", lty=0, ylim=c(-1512975363.1128519, 4510767819.111081), xlab="", ylab="")
points(factor(buffer, levels=buffer), bytes_per_second, col="black", pch="o")
lines(factor(buffer, levels=buffer), bytes_per_second, col="black", lty=1, lwd=2)
title(main="Зависимость широты пропускания от фактора", xlab="Размер буфера", ylab="Широта пропускания (байт/сек)")
text( factor(buffer, levels=buffer), bytes_per_second, labels=bytes_per_second, cex= 0.7, pos=3)
points(factor(buffer, levels=buffer), manual_bandwidth, col="red", pch="X")
lines(factor(buffer, levels=buffer), manual_bandwidth, col="red", lty=2, lwd=2)
text( factor(buffer, levels=buffer), manual_bandwidth, labels=manual_bandwidth, cex= 0.7, pos=3)
legend("bottomright", legend=c("Широта пропускания публикующего (б/с)", "Широта пропускания принимающего (б/с)"), col=c("black", "red"), lty=c(1, 2), pch=c("o", "X"), ncol=1)

Benchmark name is “PublisherFixture/ROS_BM_Publish_method” by var=buffer where subs_count=8 size=1024

#png(filename="plot.png", width = 1600, height = 900)
buffer <- c(1, 10, 100, 1000, 10000)
real_time <- c(6249.40646490663, 6107.915192913591, 5992.174665681887, 6057.0764683186035, 5982.318517967719)
cpu_time <- c(3039.782576182089, 3005.5745473444526, 3013.767389001032, 3008.9449492888198, 3003.2941593931237)
bytes_per_second <- c(1332488547.6901639, 1356733573.9255395, 1376222131.676145, 1364425590.406985, 1387171478.396817)
manual_bandwidth <- c(63697450779.432655, 54151966031.10595, 40397784930.94996, 42677174734.15156, 43473444560.08747)
manual_latency <- c(2062459.5037345835, 2086203.3690450503, 2136194.208640861, 1986702.089213444, 2202890.4056161502)
df <- data.frame("factor"=buffer, "Время отправки (нс)"=real_time, "Время отправки CPU (нс)"=cpu_time, "Широта пропускания публикующего (б/с)"=bytes_per_second, "Широта пропускания принимающего (б/с)"=manual_bandwidth, "Задержка передачи (нс)"=manual_latency)
plot(factor(buffer, levels=buffer), real_time, type="o", col="black", lty=0, ylim=c(184.67720561910846, 9068.023418680645), xlab="", ylab="")
points(factor(buffer, levels=buffer), real_time, col="black", pch="o")
lines(factor(buffer, levels=buffer), real_time, col="black", lty=1, lwd=2)
title(main="Зависимость задержки от фактора", xlab="Размер буфера", ylab="Задержка (нс)")
points(factor(buffer, levels=buffer), cpu_time, col="red", pch="X")
lines(factor(buffer, levels=buffer), cpu_time, col="red", lty=2, lwd=2)
legend("bottomright", legend=c("Время отправки (нс)", "Время отправки CPU (нс)"), col=c("black", "red"), lty=c(1, 2), pch=c("o", "X"), ncol=1)

plot(factor(buffer, levels=buffer), bytes_per_second, type="o", col="black", lty=0, ylim=c(-46348749790.622536, 111378689117.74536), xlab="", ylab="")
points(factor(buffer, levels=buffer), bytes_per_second, col="black", pch="o")
lines(factor(buffer, levels=buffer), bytes_per_second, col="black", lty=1, lwd=2)
title(main="Зависимость широты пропускания от фактора", xlab="Размер буфера", ylab="Широта пропускания (байт/сек)")
text( factor(buffer, levels=buffer), bytes_per_second, labels=bytes_per_second, cex= 0.7, pos=3)
points(factor(buffer, levels=buffer), manual_bandwidth, col="red", pch="X")
lines(factor(buffer, levels=buffer), manual_bandwidth, col="red", lty=2, lwd=2)
text( factor(buffer, levels=buffer), manual_bandwidth, labels=manual_bandwidth, cex= 0.7, pos=3)
legend("bottomright", legend=c("Широта пропускания публикующего (б/с)", "Широта пропускания принимающего (б/с)"), col=c("black", "red"), lty=c(1, 2), pch=c("o", "X"), ncol=1)

Benchmark name is “PublisherFixture/ROS_BM_Publish_method” by var=buffer where subs_count=8 size=4096

#png(filename="plot.png", width = 1600, height = 900)
buffer <- c(1, 10, 100, 1000, 10000)
real_time <- c(5298.868434206353, 5084.288325373656, 5359.818269381755, 5419.77171932831, 5512.324932717507)
cpu_time <- c(3282.7024012936004, 3203.3299574278667, 3295.026563652607, 3309.6955330579476, 3321.7468407977713)
bytes_per_second <- c(6248669858.39148, 6520187621.122169, 6252563254.584262, 6129241916.539861, 5992100707.579203)
manual_bandwidth <- c(29743578193.40341, 35891918134.00308, 22344468241.77512, 26025516391.198513, 38469930877.55172)
manual_latency <- c(7468308.709027636, 6915341.520207157, 10212650.896962786, 6906430.322168343, 6342390.803027696)
df <- data.frame("factor"=buffer, "Время отправки (нс)"=real_time, "Время отправки CPU (нс)"=cpu_time, "Широта пропускания публикующего (б/с)"=bytes_per_second, "Широта пропускания принимающего (б/с)"=manual_bandwidth, "Задержка передачи (нс)"=manual_latency)
plot(factor(buffer, levels=buffer), real_time, type="o", col="black", lty=0, ylim=c(818.227566713957, 7897.427323431417), xlab="", ylab="")
points(factor(buffer, levels=buffer), real_time, col="black", pch="o")
lines(factor(buffer, levels=buffer), real_time, col="black", lty=1, lwd=2)
title(main="Зависимость задержки от фактора", xlab="Размер буфера", ylab="Задержка (нс)")
points(factor(buffer, levels=buffer), cpu_time, col="red", pch="X")
lines(factor(buffer, levels=buffer), cpu_time, col="red", lty=2, lwd=2)
legend("bottomright", legend=c("Время отправки (нс)", "Время отправки CPU (нс)"), col=c("black", "red"), lty=c(1, 2), pch=c("o", "X"), ncol=1)

plot(factor(buffer, levels=buffer), bytes_per_second, type="o", col="black", lty=0, ylim=c(-41015127775.71324, 85477159360.84416), xlab="", ylab="")
points(factor(buffer, levels=buffer), bytes_per_second, col="black", pch="o")
lines(factor(buffer, levels=buffer), bytes_per_second, col="black", lty=1, lwd=2)
title(main="Зависимость широты пропускания от фактора", xlab="Размер буфера", ylab="Широта пропускания (байт/сек)")
text( factor(buffer, levels=buffer), bytes_per_second, labels=bytes_per_second, cex= 0.7, pos=3)
points(factor(buffer, levels=buffer), manual_bandwidth, col="red", pch="X")
lines(factor(buffer, levels=buffer), manual_bandwidth, col="red", lty=2, lwd=2)
text( factor(buffer, levels=buffer), manual_bandwidth, labels=manual_bandwidth, cex= 0.7, pos=3)
legend("bottomright", legend=c("Широта пропускания публикующего (б/с)", "Широта пропускания принимающего (б/с)"), col=c("black", "red"), lty=c(1, 2), pch=c("o", "X"), ncol=1)

Benchmark name is “PublisherFixture/ROS_BM_Publish_method” by var=buffer where subs_count=8 size=16384

#png(filename="plot.png", width = 1600, height = 900)
buffer <- c(1, 10, 100, 1000, 10000)
real_time <- c(9692.959681376462, 9742.235739851585, 9684.345799853301, 9419.618730980223, 9106.713305290123)
cpu_time <- c(8444.946042044916, 8367.012479025318, 8462.439291709787, 8141.305977483957, 7877.725071927637)
bytes_per_second <- c(13571873267.218204, 13546676451.435375, 13570170488.942522, 13985284237.868042, 14425173466.713476)
manual_bandwidth <- c(28856689590.871117, 30231073262.137306, 37944143944.3015, 28941633241.141136, 34264764504.390495)
manual_latency <- c(4243554.973943848, 5674405.101053295, 4025887.318404039, 8342028.220107794, 5255394.743360797)
df <- data.frame("factor"=buffer, "Время отправки (нс)"=real_time, "Время отправки CPU (нс)"=cpu_time, "Широта пропускания публикующего (б/с)"=bytes_per_second, "Широта пропускания принимающего (б/с)"=manual_bandwidth, "Задержка передачи (нс)"=manual_latency)
plot(factor(buffer, levels=buffer), real_time, type="o", col="black", lty=0, ylim=c(5679.408483286692, 11940.55232849253), xlab="", ylab="")
points(factor(buffer, levels=buffer), real_time, col="black", pch="o")
lines(factor(buffer, levels=buffer), real_time, col="black", lty=1, lwd=2)
title(main="Зависимость задержки от фактора", xlab="Размер буфера", ylab="Задержка (нс)")
points(factor(buffer, levels=buffer), cpu_time, col="red", pch="X")
lines(factor(buffer, levels=buffer), cpu_time, col="red", lty=2, lwd=2)
legend("bottomright", legend=c("Время отправки (нс)", "Время отправки CPU (нс)"), col=c("black", "red"), lty=c(1, 2), pch=c("o", "X"), ncol=1)

plot(factor(buffer, levels=buffer), bytes_per_second, type="o", col="black", lty=0, ylim=c(-19771443536.16121, 71262263931.89807), xlab="", ylab="")
points(factor(buffer, levels=buffer), bytes_per_second, col="black", pch="o")
lines(factor(buffer, levels=buffer), bytes_per_second, col="black", lty=1, lwd=2)
title(main="Зависимость широты пропускания от фактора", xlab="Размер буфера", ylab="Широта пропускания (байт/сек)")
text( factor(buffer, levels=buffer), bytes_per_second, labels=bytes_per_second, cex= 0.7, pos=3)
points(factor(buffer, levels=buffer), manual_bandwidth, col="red", pch="X")
lines(factor(buffer, levels=buffer), manual_bandwidth, col="red", lty=2, lwd=2)
text( factor(buffer, levels=buffer), manual_bandwidth, labels=manual_bandwidth, cex= 0.7, pos=3)
legend("bottomright", legend=c("Широта пропускания публикующего (б/с)", "Широта пропускания принимающего (б/с)"), col=c("black", "red"), lty=c(1, 2), pch=c("o", "X"), ncol=1)

Benchmark name is “PublisherFixture/ROS_BM_Publish_method” by var=buffer where subs_count=8 size=65536

#png(filename="plot.png", width = 1600, height = 900)
buffer <- c(1, 10, 100, 1000, 10000)
real_time <- c(26357.95210569732, 35193.897385136064, 32024.28410567216, 37114.691981497155, 26744.575728683914)
cpu_time <- c(13736.928344962123, 25703.564367585266, 22425.825988437267, 31354.976325669682, 13767.792037115656)
bytes_per_second <- c(19933719040.95071, 15318412942.194447, 17007940188.724356, 14200083765.948536, 19674436567.124065)
manual_bandwidth <- c(3177106811.4947248, 11175450356.203901, 6678025224.872855, 12147668777.79102, 2955778345.460847)
manual_latency <- c(77158951.52757393, 53135941.73016544, 63351209.15346719, 24121523.844174843, 82449028.50482565)
df <- data.frame("factor"=buffer, "Время отправки (нс)"=real_time, "Время отправки CPU (нс)"=cpu_time, "Широта пропускания публикующего (б/с)"=bytes_per_second, "Широта пропускания принимающего (б/с)"=manual_bandwidth, "Задержка передачи (нс)"=manual_latency)
plot(factor(buffer, levels=buffer), real_time, type="o", col="black", lty=0, ylim=c(-12225.919603996335, 63077.53993045561), xlab="", ylab="")
points(factor(buffer, levels=buffer), real_time, col="black", pch="o")
lines(factor(buffer, levels=buffer), real_time, col="black", lty=1, lwd=2)
title(main="Зависимость задержки от фактора", xlab="Размер буфера", ylab="Задержка (нс)")
points(factor(buffer, levels=buffer), cpu_time, col="red", pch="X")
lines(factor(buffer, levels=buffer), cpu_time, col="red", lty=2, lwd=2)
legend("bottomright", legend=c("Время отправки (нс)", "Время отправки CPU (нс)"), col=c("black", "red"), lty=c(1, 2), pch=c("o", "X"), ncol=1)

plot(factor(buffer, levels=buffer), bytes_per_second, type="o", col="black", lty=0, ylim=c(-19999335517.098064, 42888832903.50962), xlab="", ylab="")
points(factor(buffer, levels=buffer), bytes_per_second, col="black", pch="o")
lines(factor(buffer, levels=buffer), bytes_per_second, col="black", lty=1, lwd=2)
title(main="Зависимость широты пропускания от фактора", xlab="Размер буфера", ylab="Широта пропускания (байт/сек)")
text( factor(buffer, levels=buffer), bytes_per_second, labels=bytes_per_second, cex= 0.7, pos=3)
points(factor(buffer, levels=buffer), manual_bandwidth, col="red", pch="X")
lines(factor(buffer, levels=buffer), manual_bandwidth, col="red", lty=2, lwd=2)
text( factor(buffer, levels=buffer), manual_bandwidth, labels=manual_bandwidth, cex= 0.7, pos=3)
legend("bottomright", legend=c("Широта пропускания публикующего (б/с)", "Широта пропускания принимающего (б/с)"), col=c("black", "red"), lty=c(1, 2), pch=c("o", "X"), ncol=1)

Benchmark name is “PublisherFixture/ROS_BM_Publish_method” by var=buffer where subs_count=8 size=262144

#png(filename="plot.png", width = 1600, height = 900)
buffer <- c(1, 10, 100, 1000, 10000)
real_time <- c(109822.98327717185, 110800.22258164443, 260218.0751775884, 243600.95310142808, 76824.64563602976)
cpu_time <- c(68027.28275471374, 68091.55215840395, 125199.27996564968, 139800.24062381597, 51768.185009942725)
bytes_per_second <- c(23491295832.524227, 24476482502.333714, 8093676400.117966, 8800792829.299368, 29977588014.06074)
manual_bandwidth <- c(3779829285.59348, 2794785200.495612, 1879229365.4653416, 3328394580.4994574, 1411382350.8212028)
manual_latency <- c(118490523.2363313, 119467162.81183815, 122014240.95323467, 98086085.8001049, 113611207.19254439)
df <- data.frame("factor"=buffer, "Время отправки (нс)"=real_time, "Время отправки CPU (нс)"=cpu_time, "Широта пропускания публикующего (б/с)"=bytes_per_second, "Широта пропускания принимающего (б/с)"=manual_bandwidth, "Задержка передачи (нс)"=manual_latency)
plot(factor(buffer, levels=buffer), real_time, type="o", col="black", lty=0, ylim=c(-150769.04672159767, 462755.3069091288), xlab="", ylab="")
points(factor(buffer, levels=buffer), real_time, col="black", pch="o")
lines(factor(buffer, levels=buffer), real_time, col="black", lty=1, lwd=2)
title(main="Зависимость задержки от фактора", xlab="Размер буфера", ylab="Задержка (нс)")
points(factor(buffer, levels=buffer), cpu_time, col="red", pch="X")
lines(factor(buffer, levels=buffer), cpu_time, col="red", lty=2, lwd=2)
legend("bottomright", legend=c("Время отправки (нс)", "Время отправки CPU (нс)"), col=c("black", "red"), lty=c(1, 2), pch=c("o", "X"), ncol=1)

plot(factor(buffer, levels=buffer), bytes_per_second, type="o", col="black", lty=0, ylim=c(-27715699894.988266, 59104670259.87021), xlab="", ylab="")
points(factor(buffer, levels=buffer), bytes_per_second, col="black", pch="o")
lines(factor(buffer, levels=buffer), bytes_per_second, col="black", lty=1, lwd=2)
title(main="Зависимость широты пропускания от фактора", xlab="Размер буфера", ylab="Широта пропускания (байт/сек)")
text( factor(buffer, levels=buffer), bytes_per_second, labels=bytes_per_second, cex= 0.7, pos=3)
points(factor(buffer, levels=buffer), manual_bandwidth, col="red", pch="X")
lines(factor(buffer, levels=buffer), manual_bandwidth, col="red", lty=2, lwd=2)
text( factor(buffer, levels=buffer), manual_bandwidth, labels=manual_bandwidth, cex= 0.7, pos=3)
legend("bottomright", legend=c("Широта пропускания публикующего (б/с)", "Широта пропускания принимающего (б/с)"), col=c("black", "red"), lty=c(1, 2), pch=c("o", "X"), ncol=1)

Benchmark name is “PublisherFixture/ROS_BM_Publish_method” by var=buffer where subs_count=8 size=1048576

#png(filename="plot.png", width = 1600, height = 900)
buffer <- c(1, 10, 100, 1000, 10000)
real_time <- c(510811.6901620716, 762440.1167911757, 911047.9387184575, 601452.4260553325, 813896.3905363408)
cpu_time <- c(348529.2104119652, 510935.05517043284, 528270.1555309125, 403381.4325192258, 496177.1286857225)
bytes_per_second <- c(21468127100.79583, 11853508247.476137, 10127067200.823347, 19398732091.098022, 11799426264.071325)
manual_bandwidth <- c(2698813036.744806, 1940537714.0710998, 994764779.880153, 1060638106.6713841, 5200331369.972635)
manual_latency <- c(175578147.78588906, 135640486.32835308, 153970209.6454524, 134003672.71977839, 147217498.16139644)
df <- data.frame("factor"=buffer, "Время отправки (нс)"=real_time, "Время отправки CPU (нс)"=cpu_time, "Широта пропускания публикующего (б/с)"=bytes_per_second, "Широта пропускания принимающего (б/с)"=manual_bandwidth, "Задержка передачи (нс)"=manual_latency)
plot(factor(buffer, levels=buffer), real_time, type="o", col="black", lty=0, ylim=c(-430893.2609819042, 1690470.410112327), xlab="", ylab="")
points(factor(buffer, levels=buffer), real_time, col="black", pch="o")
lines(factor(buffer, levels=buffer), real_time, col="black", lty=1, lwd=2)
title(main="Зависимость задержки от фактора", xlab="Размер буфера", ylab="Задержка (нс)")
points(factor(buffer, levels=buffer), cpu_time, col="red", pch="X")
lines(factor(buffer, levels=buffer), cpu_time, col="red", lty=2, lwd=2)
legend("bottomright", legend=c("Время отправки (нс)", "Время отправки CPU (нс)"), col=c("black", "red"), lty=c(1, 2), pch=c("o", "X"), ncol=1)

plot(factor(buffer, levels=buffer), bytes_per_second, type="o", col="black", lty=0, ylim=c(-25031919518.075546, 47494811398.751526), xlab="", ylab="")
points(factor(buffer, levels=buffer), bytes_per_second, col="black", pch="o")
lines(factor(buffer, levels=buffer), bytes_per_second, col="black", lty=1, lwd=2)
title(main="Зависимость широты пропускания от фактора", xlab="Размер буфера", ylab="Широта пропускания (байт/сек)")
text( factor(buffer, levels=buffer), bytes_per_second, labels=bytes_per_second, cex= 0.7, pos=3)
points(factor(buffer, levels=buffer), manual_bandwidth, col="red", pch="X")
lines(factor(buffer, levels=buffer), manual_bandwidth, col="red", lty=2, lwd=2)
text( factor(buffer, levels=buffer), manual_bandwidth, labels=manual_bandwidth, cex= 0.7, pos=3)
legend("bottomright", legend=c("Широта пропускания публикующего (б/с)", "Широта пропускания принимающего (б/с)"), col=c("black", "red"), lty=c(1, 2), pch=c("o", "X"), ncol=1)

Benchmark name is “PublisherFixture/ROS_BM_Publish_method” by var=buffer where subs_count=8 size=4194304

#png(filename="plot.png", width = 1600, height = 900)
buffer <- c(1, 10, 100, 1000, 10000)
real_time <- c(1554646.5007241913, 1321079.7203019361, 1115102.688853146, 1596832.6717077282, 1350034.4842400574)
cpu_time <- c(1124270.9667290214, 1049516.1158216244, 952194.2029372273, 1182508.6655702316, 1125260.5958965074)
bytes_per_second <- c(22719089450.150375, 26569579728.799263, 30131409511.12666, 21702803410.23856, 25328765815.109386)
manual_bandwidth <- c(754037456.8582256, 472345704.5246213, 380410481.8633764, 512917373.6292697, 609886016.6254795)
manual_latency <- c(346825505.2583333, 339775773.6261905, 456539274.82666665, 340102879.95178574, 332545706.88531744)
df <- data.frame("factor"=buffer, "Время отправки (нс)"=real_time, "Время отправки CPU (нс)"=cpu_time, "Широта пропускания публикующего (б/с)"=bytes_per_second, "Широта пропускания принимающего (б/с)"=manual_bandwidth, "Задержка передачи (нс)"=manual_latency)
plot(factor(buffer, levels=buffer), real_time, type="o", col="black", lty=0, ylim=c(55786.66803878639, 2493240.206606169), xlab="", ylab="")
points(factor(buffer, levels=buffer), real_time, col="black", pch="o")
lines(factor(buffer, levels=buffer), real_time, col="black", lty=1, lwd=2)
title(main="Зависимость задержки от фактора", xlab="Размер буфера", ylab="Задержка (нс)")
points(factor(buffer, levels=buffer), cpu_time, col="red", pch="X")
lines(factor(buffer, levels=buffer), cpu_time, col="red", lty=2, lwd=2)
legend("bottomright", legend=c("Время отправки (нс)", "Время отправки CPU (нс)"), col=c("black", "red"), lty=c(1, 2), pch=c("o", "X"), ncol=1)

plot(factor(buffer, levels=buffer), bytes_per_second, type="o", col="black", lty=0, ylim=c(-21902975258.136833, 52414795251.12687), xlab="", ylab="")
points(factor(buffer, levels=buffer), bytes_per_second, col="black", pch="o")
lines(factor(buffer, levels=buffer), bytes_per_second, col="black", lty=1, lwd=2)
title(main="Зависимость широты пропускания от фактора", xlab="Размер буфера", ylab="Широта пропускания (байт/сек)")
text( factor(buffer, levels=buffer), bytes_per_second, labels=bytes_per_second, cex= 0.7, pos=3)
points(factor(buffer, levels=buffer), manual_bandwidth, col="red", pch="X")
lines(factor(buffer, levels=buffer), manual_bandwidth, col="red", lty=2, lwd=2)
text( factor(buffer, levels=buffer), manual_bandwidth, labels=manual_bandwidth, cex= 0.7, pos=3)
legend("bottomright", legend=c("Широта пропускания публикующего (б/с)", "Широта пропускания принимающего (б/с)"), col=c("black", "red"), lty=c(1, 2), pch=c("o", "X"), ncol=1)

Benchmark name is “PublisherFixture/ROS_BM_Publish_method” by var=buffer where subs_count=8 size=16777216

#png(filename="plot.png", width = 1600, height = 900)
buffer <- c(1, 10, 100, 1000, 10000)
real_time <- c(26143153.374057334, 26556223.67240634, 25119723.291980334, 25506102.50713297, 25385952.37243373)
cpu_time <- c(22511168.3370364, 22748359.231025398, 22583206.471997075, 22445104.485725712, 22495410.279310785)
bytes_per_second <- c(5182736990.753264, 5096349623.214842, 5360592562.3836975, 5320514158.94353, 5306957246.9734745)
manual_bandwidth <- c(170878241.28796715, 197037880.00146163, 156218973.88218027, 147643137.72752073, 152538314.27993858)
manual_latency <- c(1256933917.45, 1190112701.95, 1341391983.25, 1297891271.6, 1372224844.9)
df <- data.frame("factor"=buffer, "Время отправки (нс)"=real_time, "Время отправки CPU (нс)"=cpu_time, "Широта пропускания публикующего (б/с)"=bytes_per_second, "Широта пропускания принимающего (б/с)"=manual_bandwidth, "Задержка передачи (нс)"=manual_latency)
plot(factor(buffer, levels=buffer), real_time, type="o", col="black", lty=0, ylim=c(16048226.678760696, 32953101.479371354), xlab="", ylab="")
points(factor(buffer, levels=buffer), real_time, col="black", pch="o")
lines(factor(buffer, levels=buffer), real_time, col="black", lty=1, lwd=2)
title(main="Зависимость задержки от фактора", xlab="Размер буфера", ylab="Задержка (нс)")
points(factor(buffer, levels=buffer), cpu_time, col="red", pch="X")
lines(factor(buffer, levels=buffer), cpu_time, col="red", lty=2, lwd=2)
legend("bottomright", legend=c("Время отправки (нс)", "Время отправки CPU (нс)"), col=c("black", "red"), lty=c(1, 2), pch=c("o", "X"), ncol=1)

plot(factor(buffer, levels=buffer), bytes_per_second, type="o", col="black", lty=0, ylim=c(-3245813616.4552426, 8754049316.566462), xlab="", ylab="")
points(factor(buffer, levels=buffer), bytes_per_second, col="black", pch="o")
lines(factor(buffer, levels=buffer), bytes_per_second, col="black", lty=1, lwd=2)
title(main="Зависимость широты пропускания от фактора", xlab="Размер буфера", ylab="Широта пропускания (байт/сек)")
text( factor(buffer, levels=buffer), bytes_per_second, labels=bytes_per_second, cex= 0.7, pos=3)
points(factor(buffer, levels=buffer), manual_bandwidth, col="red", pch="X")
lines(factor(buffer, levels=buffer), manual_bandwidth, col="red", lty=2, lwd=2)
text( factor(buffer, levels=buffer), manual_bandwidth, labels=manual_bandwidth, cex= 0.7, pos=3)
legend("bottomright", legend=c("Широта пропускания публикующего (б/с)", "Широта пропускания принимающего (б/с)"), col=c("black", "red"), lty=c(1, 2), pch=c("o", "X"), ncol=1)

Benchmark name is “PublisherFixture/ROS_BM_Publish_method” by var=buffer where subs_count=8 size=67108864

#png(filename="plot.png", width = 1600, height = 900)
buffer <- c(1, 10, 100, 1000, 10000)
real_time <- c(120207000.35001254, 135832183.7201038, 122985828.25716428, 128046437.21431474, 136672580.1200664)
cpu_time <- c(94906323.32498308, 96267461.45996548, 94697308.01428925, 94568736.32858397, 95237181.67998594)
bytes_per_second <- c(4522665854.849938, 4054744034.389286, 4432288992.212332, 4238887680.302912, 3988117682.2469215)
manual_bandwidth <- c(129915114.14094861, 110213680.28714296, 114933284.83632219, 114433365.43745105, 93005388.66803208)
manual_latency <- c(4631043895.9, 4875863732.6, 4698611895.5, 4699079887.8, 4690898936.3)
df <- data.frame("factor"=buffer, "Время отправки (нс)"=real_time, "Время отправки CPU (нс)"=cpu_time, "Широта пропускания публикующего (б/с)"=bytes_per_second, "Широта пропускания принимающего (б/с)"=manual_bandwidth, "Задержка передачи (нс)"=manual_latency)
plot(factor(buffer, levels=buffer), real_time, type="o", col="black", lty=0, ylim=c(42560889.881241515, 188680426.56740886), xlab="", ylab="")
points(factor(buffer, levels=buffer), real_time, col="black", pch="o")
lines(factor(buffer, levels=buffer), real_time, col="black", lty=1, lwd=2)
title(main="Зависимость задержки от фактора", xlab="Размер буфера", ylab="Задержка (нс)")
points(factor(buffer, levels=buffer), cpu_time, col="red", pch="X")
lines(factor(buffer, levels=buffer), cpu_time, col="red", lty=2, lwd=2)
legend("bottomright", legend=c("Время отправки (нс)", "Время отправки CPU (нс)"), col=c("black", "red"), lty=c(1, 2), pch=c("o", "X"), ncol=1)

plot(factor(buffer, levels=buffer), bytes_per_second, type="o", col="black", lty=0, ylim=c(-3153764150.9111233, 7769435394.429093), xlab="", ylab="")
points(factor(buffer, levels=buffer), bytes_per_second, col="black", pch="o")
lines(factor(buffer, levels=buffer), bytes_per_second, col="black", lty=1, lwd=2)
title(main="Зависимость широты пропускания от фактора", xlab="Размер буфера", ylab="Широта пропускания (байт/сек)")
text( factor(buffer, levels=buffer), bytes_per_second, labels=bytes_per_second, cex= 0.7, pos=3)
points(factor(buffer, levels=buffer), manual_bandwidth, col="red", pch="X")
lines(factor(buffer, levels=buffer), manual_bandwidth, col="red", lty=2, lwd=2)
text( factor(buffer, levels=buffer), manual_bandwidth, labels=manual_bandwidth, cex= 0.7, pos=3)
legend("bottomright", legend=c("Широта пропускания публикующего (б/с)", "Широта пропускания принимающего (б/с)"), col=c("black", "red"), lty=c(1, 2), pch=c("o", "X"), ncol=1)

Benchmark name is “ClientFixture/ROS_BM_Service” by var=size where

#png(filename="plot.png", width = 1600, height = 900)
size <- c(1024, 4096, 16384, 65536, 262144, 1048576, 4194304, 16777216, 67108864)
real_time <- c(953685.2691267472, 979528.1199712123, 1057962.4634684217, 1101019.5262034556, 16208963.116655976, 6030580.885001199, 14460727.4104222, 50117277.2285567, 276020631.85022414)
cpu_time <- c(322553.1072570725, 322758.7631504921, 326605.58646986476, 345976.2866855526, 446579.5666666593, 635461.9456249997, 2243157.250000002, 4666441.657142859, 57243083.19999993)
bytes_per_second <- c(2150095.0702272914, 8398018.33243535, 31059254.2002196, 119372696.41049369, 153667719.02438125, 379524282.90441144, 581071394.0045922, 669678524.6846191, 486639880.40417826)
req_t <- c(4133046.6, 4149062.7, 4217649.9, 4202854.5, 70529160.0, 16443369.8, 27409928.5, 43983998.4, 293352139.7)
resp_t <- c(62681.1, 74235.6, 82369.6, 631606.4, 595521.6, 10180450.4, 35101911.7, 170881060.4, 806409003.2)
df <- data.frame("factor"=size, "Время отправки (нс)"=real_time, "Время отправки CPU (нс)"=cpu_time, "Широта пропускания публикующего (б/с)"=bytes_per_second, "Время запроса (нс)"=req_t, "Время ответа (нс)"=resp_t)
plot(factor(size, levels=size), real_time, type="o", col="black", lty=0, ylim=c(-160355047.63058916, 436698232.5880704), xlab="", ylab="")
points(factor(size, levels=size), real_time, col="black", pch="o")
lines(factor(size, levels=size), real_time, col="black", lty=1, lwd=2)
title(main="Зависимость задержки от фактора", xlab="Размер сообщения (б)", ylab="Задержка (нс)")
points(factor(size, levels=size), cpu_time, col="red", pch="X")
lines(factor(size, levels=size), cpu_time, col="red", lty=2, lwd=2)
legend("bottomright", legend=c("Время отправки (нс)", "Время отправки CPU (нс)"), col=c("black", "red"), lty=c(1, 2), pch=c("o", "X"), ncol=1)

plot(factor(size, levels=size), bytes_per_second, type="o", col="black", lty=0, ylim=c(-537356147.1466799, 1209184766.9015262), xlab="", ylab="")
points(factor(size, levels=size), bytes_per_second, col="black", pch="o")
lines(factor(size, levels=size), bytes_per_second, col="black", lty=1, lwd=2)
title(main="Зависимость широты пропускания от фактора", xlab="Размер сообщения (б)", ylab="Широта пропускания (байт/сек)")
text( factor(size, levels=size), bytes_per_second, labels=bytes_per_second, cex= 0.7, pos=3)
legend("bottomright", legend=c("Широта пропускания публикующего (б/с)"), col=c("black"), lty=c(1), pch=c("o"), ncol=1)

Пример обработки данных

Ефремов Михаил

Benchmark name is “PublisherFixture/ROS_BM_Publish_method” by var=subs_count where size=1024 buffer=1

Benchmark name is “PublisherFixture/ROS_BM_Publish_method” by var=subs_count where size=1024 buffer=10

Benchmark name is “PublisherFixture/ROS_BM_Publish_method” by var=subs_count where size=1024 buffer=100

Benchmark name is “PublisherFixture/ROS_BM_Publish_method” by var=subs_count where size=1024 buffer=1000

Benchmark name is “PublisherFixture/ROS_BM_Publish_method” by var=subs_count where size=1024 buffer=10000

Benchmark name is “PublisherFixture/ROS_BM_Publish_method” by var=subs_count where size=4096 buffer=1

Benchmark name is “PublisherFixture/ROS_BM_Publish_method” by var=subs_count where size=4096 buffer=10

Benchmark name is “PublisherFixture/ROS_BM_Publish_method” by var=subs_count where size=4096 buffer=100

Benchmark name is “PublisherFixture/ROS_BM_Publish_method” by var=subs_count where size=4096 buffer=1000

Benchmark name is “PublisherFixture/ROS_BM_Publish_method” by var=subs_count where size=4096 buffer=10000

Benchmark name is “PublisherFixture/ROS_BM_Publish_method” by var=subs_count where size=16384 buffer=1

Benchmark name is “PublisherFixture/ROS_BM_Publish_method” by var=subs_count where size=16384 buffer=10

Benchmark name is “PublisherFixture/ROS_BM_Publish_method” by var=subs_count where size=16384 buffer=100

Benchmark name is “PublisherFixture/ROS_BM_Publish_method” by var=subs_count where size=16384 buffer=1000

Benchmark name is “PublisherFixture/ROS_BM_Publish_method” by var=subs_count where size=16384 buffer=10000

Benchmark name is “PublisherFixture/ROS_BM_Publish_method” by var=subs_count where size=65536 buffer=1

Benchmark name is “PublisherFixture/ROS_BM_Publish_method” by var=subs_count where size=65536 buffer=10

Benchmark name is “PublisherFixture/ROS_BM_Publish_method” by var=subs_count where size=65536 buffer=100

Benchmark name is “PublisherFixture/ROS_BM_Publish_method” by var=subs_count where size=65536 buffer=1000

Benchmark name is “PublisherFixture/ROS_BM_Publish_method” by var=subs_count where size=65536 buffer=10000

Benchmark name is “PublisherFixture/ROS_BM_Publish_method” by var=subs_count where size=262144 buffer=1

Benchmark name is “PublisherFixture/ROS_BM_Publish_method” by var=subs_count where size=262144 buffer=10

Benchmark name is “PublisherFixture/ROS_BM_Publish_method” by var=subs_count where size=262144 buffer=100

Benchmark name is “PublisherFixture/ROS_BM_Publish_method” by var=subs_count where size=262144 buffer=1000

Benchmark name is “PublisherFixture/ROS_BM_Publish_method” by var=subs_count where size=262144 buffer=10000

Benchmark name is “PublisherFixture/ROS_BM_Publish_method” by var=subs_count where size=1048576 buffer=1

Benchmark name is “PublisherFixture/ROS_BM_Publish_method” by var=subs_count where size=1048576 buffer=10

Benchmark name is “PublisherFixture/ROS_BM_Publish_method” by var=subs_count where size=1048576 buffer=100

Benchmark name is “PublisherFixture/ROS_BM_Publish_method” by var=subs_count where size=1048576 buffer=1000

Benchmark name is “PublisherFixture/ROS_BM_Publish_method” by var=subs_count where size=1048576 buffer=10000

Benchmark name is “PublisherFixture/ROS_BM_Publish_method” by var=subs_count where size=4194304 buffer=1

Benchmark name is “PublisherFixture/ROS_BM_Publish_method” by var=subs_count where size=4194304 buffer=10

Benchmark name is “PublisherFixture/ROS_BM_Publish_method” by var=subs_count where size=4194304 buffer=100

Benchmark name is “PublisherFixture/ROS_BM_Publish_method” by var=subs_count where size=4194304 buffer=1000

Benchmark name is “PublisherFixture/ROS_BM_Publish_method” by var=subs_count where size=4194304 buffer=10000

Benchmark name is “PublisherFixture/ROS_BM_Publish_method” by var=subs_count where size=16777216 buffer=1

Benchmark name is “PublisherFixture/ROS_BM_Publish_method” by var=subs_count where size=16777216 buffer=10

Benchmark name is “PublisherFixture/ROS_BM_Publish_method” by var=subs_count where size=16777216 buffer=100

Benchmark name is “PublisherFixture/ROS_BM_Publish_method” by var=subs_count where size=16777216 buffer=1000

Benchmark name is “PublisherFixture/ROS_BM_Publish_method” by var=subs_count where size=16777216 buffer=10000

Benchmark name is “PublisherFixture/ROS_BM_Publish_method” by var=subs_count where size=67108864 buffer=1

Benchmark name is “PublisherFixture/ROS_BM_Publish_method” by var=subs_count where size=67108864 buffer=10

Benchmark name is “PublisherFixture/ROS_BM_Publish_method” by var=subs_count where size=67108864 buffer=100

Benchmark name is “PublisherFixture/ROS_BM_Publish_method” by var=subs_count where size=67108864 buffer=1000

Benchmark name is “PublisherFixture/ROS_BM_Publish_method” by var=subs_count where size=67108864 buffer=10000

Benchmark name is “PublisherFixture/ROS_BM_Publish_method” by var=size where subs_count=1 buffer=1

Benchmark name is “PublisherFixture/ROS_BM_Publish_method” by var=size where subs_count=1 buffer=10

Benchmark name is “PublisherFixture/ROS_BM_Publish_method” by var=size where subs_count=1 buffer=100

Benchmark name is “PublisherFixture/ROS_BM_Publish_method” by var=size where subs_count=1 buffer=1000

Benchmark name is “PublisherFixture/ROS_BM_Publish_method” by var=size where subs_count=1 buffer=10000

Benchmark name is “PublisherFixture/ROS_BM_Publish_method” by var=size where subs_count=2 buffer=1

Benchmark name is “PublisherFixture/ROS_BM_Publish_method” by var=size where subs_count=2 buffer=10

Benchmark name is “PublisherFixture/ROS_BM_Publish_method” by var=size where subs_count=2 buffer=100

Benchmark name is “PublisherFixture/ROS_BM_Publish_method” by var=size where subs_count=2 buffer=1000

Benchmark name is “PublisherFixture/ROS_BM_Publish_method” by var=size where subs_count=2 buffer=10000

Benchmark name is “PublisherFixture/ROS_BM_Publish_method” by var=size where subs_count=4 buffer=1

Benchmark name is “PublisherFixture/ROS_BM_Publish_method” by var=size where subs_count=4 buffer=10

Benchmark name is “PublisherFixture/ROS_BM_Publish_method” by var=size where subs_count=4 buffer=100

Benchmark name is “PublisherFixture/ROS_BM_Publish_method” by var=size where subs_count=4 buffer=1000

Benchmark name is “PublisherFixture/ROS_BM_Publish_method” by var=size where subs_count=4 buffer=10000

Benchmark name is “PublisherFixture/ROS_BM_Publish_method” by var=size where subs_count=8 buffer=1

Benchmark name is “PublisherFixture/ROS_BM_Publish_method” by var=size where subs_count=8 buffer=10

Benchmark name is “PublisherFixture/ROS_BM_Publish_method” by var=size where subs_count=8 buffer=100

Benchmark name is “PublisherFixture/ROS_BM_Publish_method” by var=size where subs_count=8 buffer=1000

Benchmark name is “PublisherFixture/ROS_BM_Publish_method” by var=size where subs_count=8 buffer=10000

Benchmark name is “PublisherFixture/ROS_BM_Publish_method” by var=buffer where subs_count=1 size=1024

Benchmark name is “PublisherFixture/ROS_BM_Publish_method” by var=buffer where subs_count=1 size=4096

Benchmark name is “PublisherFixture/ROS_BM_Publish_method” by var=buffer where subs_count=1 size=16384

Benchmark name is “PublisherFixture/ROS_BM_Publish_method” by var=buffer where subs_count=1 size=65536

Benchmark name is “PublisherFixture/ROS_BM_Publish_method” by var=buffer where subs_count=1 size=262144

Benchmark name is “PublisherFixture/ROS_BM_Publish_method” by var=buffer where subs_count=1 size=1048576

Benchmark name is “PublisherFixture/ROS_BM_Publish_method” by var=buffer where subs_count=1 size=4194304

Benchmark name is “PublisherFixture/ROS_BM_Publish_method” by var=buffer where subs_count=1 size=16777216

Benchmark name is “PublisherFixture/ROS_BM_Publish_method” by var=buffer where subs_count=1 size=67108864

Benchmark name is “PublisherFixture/ROS_BM_Publish_method” by var=buffer where subs_count=2 size=1024

Benchmark name is “PublisherFixture/ROS_BM_Publish_method” by var=buffer where subs_count=2 size=4096

Benchmark name is “PublisherFixture/ROS_BM_Publish_method” by var=buffer where subs_count=2 size=16384

Benchmark name is “PublisherFixture/ROS_BM_Publish_method” by var=buffer where subs_count=2 size=65536